From a399488c2799e1acca0961f80a6c116a3330190c Mon Sep 17 00:00:00 2001 From: Sebastian Thiel Date: Wed, 8 Apr 2015 16:54:50 +0200 Subject: [PATCH] fix(version-up): v0.1.5 * fix documentation link in Cargo.toml * adjust to latest hyper. It's not even out yet, but people can't build the APIs anyway. --- etc/api/type-api.yaml | 2 +- gen/adexchangebuyer1d3/Cargo.toml | 4 +- gen/adexchangebuyer1d3/README.md | 2 +- gen/adexchangebuyer1d3/src/cmn.rs | 9 +- gen/adexchangebuyer1d3/src/lib.rs | 564 +- gen/adexchangeseller2/Cargo.toml | 4 +- gen/adexchangeseller2/README.md | 2 +- gen/adexchangeseller2/src/cmn.rs | 9 +- gen/adexchangeseller2/src/lib.rs | 368 +- gen/admin1_directory/Cargo.toml | 4 +- gen/admin1_directory/README.md | 2 +- gen/admin1_directory/src/cmn.rs | 9 +- gen/admin1_directory/src/lib.rs | 1722 +++--- gen/admin1_reports/Cargo.toml | 4 +- gen/admin1_reports/README.md | 2 +- gen/admin1_reports/src/cmn.rs | 9 +- gen/admin1_reports/src/lib.rs | 224 +- gen/admin2_email_migration/Cargo.toml | 4 +- gen/admin2_email_migration/README.md | 2 +- gen/admin2_email_migration/src/cmn.rs | 9 +- gen/admin2_email_migration/src/lib.rs | 54 +- gen/adsense1d4/Cargo.toml | 4 +- gen/adsense1d4/README.md | 2 +- gen/adsense1d4/src/cmn.rs | 9 +- gen/adsense1d4/src/lib.rs | 1064 ++-- gen/adsensehost4d1/Cargo.toml | 4 +- gen/adsensehost4d1/README.md | 2 +- gen/adsensehost4d1/src/cmn.rs | 9 +- gen/adsensehost4d1/src/lib.rs | 720 ++- gen/analytics3/Cargo.toml | 4 +- gen/analytics3/README.md | 2 +- gen/analytics3/src/cmn.rs | 9 +- gen/analytics3/src/lib.rs | 2068 ++++--- gen/androidenterprise1/Cargo.toml | 4 +- gen/androidenterprise1/README.md | 2 +- gen/androidenterprise1/src/cmn.rs | 9 +- gen/androidenterprise1/src/lib.rs | 1176 ++-- gen/androidpublisher2/Cargo.toml | 4 +- gen/androidpublisher2/README.md | 2 +- gen/androidpublisher2/src/cmn.rs | 9 +- gen/androidpublisher2/src/lib.rs | 1304 +++-- gen/appsactivity1/Cargo.toml | 4 +- gen/appsactivity1/README.md | 2 +- gen/appsactivity1/src/cmn.rs | 9 +- gen/appsactivity1/src/lib.rs | 64 +- gen/appstate1/Cargo.toml | 4 +- gen/appstate1/README.md | 2 +- gen/appstate1/src/cmn.rs | 9 +- gen/appstate1/src/lib.rs | 138 +- gen/audit1/Cargo.toml | 4 +- gen/audit1/README.md | 2 +- gen/audit1/src/cmn.rs | 9 +- gen/audit1/src/lib.rs | 70 +- gen/autoscaler1_beta2/Cargo.toml | 4 +- gen/autoscaler1_beta2/README.md | 2 +- gen/autoscaler1_beta2/src/cmn.rs | 9 +- gen/autoscaler1_beta2/src/lib.rs | 310 +- gen/bigquery2/Cargo.toml | 4 +- gen/bigquery2/README.md | 2 +- gen/bigquery2/src/cmn.rs | 9 +- gen/bigquery2/src/lib.rs | 576 +- gen/blogger3/Cargo.toml | 4 +- gen/blogger3/README.md | 2 +- gen/blogger3/src/cmn.rs | 9 +- gen/blogger3/src/lib.rs | 998 ++-- gen/books1/Cargo.toml | 4 +- gen/books1/README.md | 2 +- gen/books1/src/cmn.rs | 9 +- gen/books1/src/lib.rs | 1342 +++-- gen/calendar3/Cargo.toml | 4 +- gen/calendar3/README.md | 2 +- gen/calendar3/src/cmn.rs | 9 +- gen/calendar3/src/lib.rs | 1072 ++-- gen/civicinfo2/Cargo.toml | 4 +- gen/civicinfo2/README.md | 2 +- gen/civicinfo2/src/cmn.rs | 9 +- gen/civicinfo2/src/lib.rs | 160 +- gen/cloudlatencytest2/Cargo.toml | 4 +- gen/cloudlatencytest2/README.md | 2 +- gen/cloudlatencytest2/src/cmn.rs | 9 +- gen/cloudlatencytest2/src/lib.rs | 72 +- gen/cloudmonitoring2_beta2/Cargo.toml | 4 +- gen/cloudmonitoring2_beta2/README.md | 2 +- gen/cloudmonitoring2_beta2/src/cmn.rs | 9 +- gen/cloudmonitoring2_beta2/src/lib.rs | 230 +- gen/cloudsearch1/Cargo.toml | 4 +- gen/cloudsearch1/README.md | 2 +- gen/cloudsearch1/src/cmn.rs | 9 +- gen/cloudsearch1/src/lib.rs | 202 +- gen/compute1/Cargo.toml | 4 +- gen/compute1/README.md | 2 +- gen/compute1/src/cmn.rs | 9 +- gen/compute1/src/lib.rs | 3922 +++++++------- gen/container1_beta1/Cargo.toml | 4 +- gen/container1_beta1/README.md | 2 +- gen/container1_beta1/src/cmn.rs | 9 +- gen/container1_beta1/src/lib.rs | 212 +- gen/content2/Cargo.toml | 4 +- gen/content2/README.md | 2 +- gen/content2/src/cmn.rs | 9 +- gen/content2/src/lib.rs | 1050 ++-- gen/coordinate1/Cargo.toml | 4 +- gen/coordinate1/README.md | 2 +- gen/coordinate1/src/cmn.rs | 9 +- gen/coordinate1/src/lib.rs | 446 +- gen/customsearch1/Cargo.toml | 4 +- gen/customsearch1/README.md | 2 +- gen/customsearch1/src/cmn.rs | 9 +- gen/customsearch1/src/lib.rs | 112 +- gen/dataflow1_b4/Cargo.toml | 4 +- gen/dataflow1_b4/README.md | 2 +- gen/dataflow1_b4/src/cmn.rs | 9 +- gen/dataflow1_b4/src/lib.rs | 20 +- gen/datastore1_beta2/Cargo.toml | 4 +- gen/datastore1_beta2/README.md | 2 +- gen/datastore1_beta2/src/cmn.rs | 9 +- gen/datastore1_beta2/src/lib.rs | 164 +- gen/deploymentmanager2_beta1/Cargo.toml | 4 +- gen/deploymentmanager2_beta1/README.md | 2 +- gen/deploymentmanager2_beta1/src/cmn.rs | 9 +- gen/deploymentmanager2_beta1/src/lib.rs | 340 +- gen/dfareporting2/Cargo.toml | 4 +- gen/dfareporting2/README.md | 2 +- gen/dfareporting2/src/cmn.rs | 9 +- gen/dfareporting2/src/lib.rs | 4812 ++++++++--------- gen/discovery1/Cargo.toml | 4 +- gen/discovery1/README.md | 2 +- gen/discovery1/src/cmn.rs | 9 +- gen/discovery1/src/lib.rs | 72 +- gen/dns1_beta1/Cargo.toml | 4 +- gen/dns1_beta1/README.md | 2 +- gen/dns1_beta1/src/cmn.rs | 9 +- gen/dns1_beta1/src/lib.rs | 286 +- gen/doubleclickbidmanager1/Cargo.toml | 4 +- gen/doubleclickbidmanager1/README.md | 2 +- gen/doubleclickbidmanager1/src/cmn.rs | 9 +- gen/doubleclickbidmanager1/src/lib.rs | 200 +- gen/doubleclicksearch2/Cargo.toml | 4 +- gen/doubleclicksearch2/README.md | 2 +- gen/doubleclicksearch2/src/cmn.rs | 9 +- gen/doubleclicksearch2/src/lib.rs | 294 +- gen/drive2/Cargo.toml | 4 +- gen/drive2/README.md | 2 +- gen/drive2/src/cmn.rs | 9 +- gen/drive2/src/lib.rs | 1630 +++--- gen/fitness1/Cargo.toml | 4 +- gen/fitness1/README.md | 2 +- gen/fitness1/src/cmn.rs | 9 +- gen/fitness1/src/lib.rs | 308 +- gen/freebase1/Cargo.toml | 4 +- gen/freebase1/README.md | 2 +- gen/freebase1/src/cmn.rs | 9 +- gen/freebase1/src/lib.rs | 122 +- gen/freebase1_sandbox/Cargo.toml | 4 +- gen/freebase1_sandbox/README.md | 2 +- gen/freebase1_sandbox/src/cmn.rs | 9 +- gen/freebase1_sandbox/src/lib.rs | 122 +- gen/fusiontables2/Cargo.toml | 4 +- gen/fusiontables2/README.md | 2 +- gen/fusiontables2/src/cmn.rs | 9 +- gen/fusiontables2/src/lib.rs | 860 ++- gen/games1/Cargo.toml | 4 +- gen/games1/README.md | 2 +- gen/games1/src/cmn.rs | 9 +- gen/games1/src/lib.rs | 1422 +++-- .../Cargo.toml | 4 +- .../README.md | 2 +- .../src/cmn.rs | 9 +- .../src/lib.rs | 338 +- gen/gamesmanagement1_management/Cargo.toml | 4 +- gen/gamesmanagement1_management/README.md | 2 +- gen/gamesmanagement1_management/src/cmn.rs | 9 +- gen/gamesmanagement1_management/src/lib.rs | 640 ++- gen/gan1_beta1/Cargo.toml | 4 +- gen/gan1_beta1/README.md | 2 +- gen/gan1_beta1/src/cmn.rs | 9 +- gen/gan1_beta1/src/lib.rs | 412 +- gen/genomics1_beta2/Cargo.toml | 4 +- gen/genomics1_beta2/README.md | 2 +- gen/genomics1_beta2/src/cmn.rs | 9 +- gen/genomics1_beta2/src/lib.rs | 1432 +++-- gen/gmail1/Cargo.toml | 4 +- gen/gmail1/README.md | 2 +- gen/gmail1/src/cmn.rs | 9 +- gen/gmail1/src/lib.rs | 746 ++- gen/groupsmigration1/Cargo.toml | 4 +- gen/groupsmigration1/README.md | 2 +- gen/groupsmigration1/src/cmn.rs | 9 +- gen/groupsmigration1/src/lib.rs | 52 +- gen/groupssettings1/Cargo.toml | 4 +- gen/groupssettings1/README.md | 2 +- gen/groupssettings1/src/cmn.rs | 9 +- gen/groupssettings1/src/lib.rs | 96 +- gen/identitytoolkit3/Cargo.toml | 4 +- gen/identitytoolkit3/README.md | 2 +- gen/identitytoolkit3/src/cmn.rs | 9 +- gen/identitytoolkit3/src/lib.rs | 228 +- gen/licensing1/Cargo.toml | 4 +- gen/licensing1/README.md | 2 +- gen/licensing1/src/cmn.rs | 9 +- gen/licensing1/src/lib.rs | 210 +- gen/logging1_beta3/Cargo.toml | 4 +- gen/logging1_beta3/README.md | 2 +- gen/logging1_beta3/src/cmn.rs | 9 +- gen/logging1_beta3/src/lib.rs | 404 +- gen/manager1_beta2/Cargo.toml | 4 +- gen/manager1_beta2/README.md | 2 +- gen/manager1_beta2/src/cmn.rs | 9 +- gen/manager1_beta2/src/lib.rs | 232 +- gen/mapsengine1/Cargo.toml | 4 +- gen/mapsengine1/README.md | 2 +- gen/mapsengine1/src/cmn.rs | 9 +- gen/mapsengine1/src/lib.rs | 1924 ++++--- gen/mirror1/Cargo.toml | 4 +- gen/mirror1/README.md | 2 +- gen/mirror1/src/cmn.rs | 9 +- gen/mirror1/src/lib.rs | 598 +- gen/oauth2_v2/Cargo.toml | 4 +- gen/oauth2_v2/README.md | 2 +- gen/oauth2_v2/src/cmn.rs | 9 +- gen/oauth2_v2/src/lib.rs | 122 +- gen/pagespeedonline2/Cargo.toml | 4 +- gen/pagespeedonline2/README.md | 2 +- gen/pagespeedonline2/src/cmn.rs | 9 +- gen/pagespeedonline2/src/lib.rs | 60 +- gen/plus1/Cargo.toml | 4 +- gen/plus1/README.md | 2 +- gen/plus1/src/cmn.rs | 9 +- gen/plus1/src/lib.rs | 364 +- gen/plusdomains1/Cargo.toml | 4 +- gen/plusdomains1/README.md | 2 +- gen/plusdomains1/src/cmn.rs | 9 +- gen/plusdomains1/src/lib.rs | 554 +- gen/prediction1d6/Cargo.toml | 4 +- gen/prediction1d6/README.md | 2 +- gen/prediction1d6/src/cmn.rs | 9 +- gen/prediction1d6/src/lib.rs | 228 +- gen/pubsub1_beta2/Cargo.toml | 4 +- gen/pubsub1_beta2/README.md | 2 +- gen/pubsub1_beta2/src/cmn.rs | 9 +- gen/pubsub1_beta2/src/lib.rs | 338 +- gen/qpxexpress1/Cargo.toml | 4 +- gen/qpxexpress1/README.md | 2 +- gen/qpxexpress1/src/cmn.rs | 9 +- gen/qpxexpress1/src/lib.rs | 50 +- gen/replicapool1_beta2/Cargo.toml | 4 +- gen/replicapool1_beta2/README.md | 2 +- gen/replicapool1_beta2/src/cmn.rs | 9 +- gen/replicapool1_beta2/src/lib.rs | 354 +- gen/replicapoolupdater1_beta1/Cargo.toml | 4 +- gen/replicapoolupdater1_beta1/README.md | 2 +- gen/replicapoolupdater1_beta1/src/cmn.rs | 9 +- gen/replicapoolupdater1_beta1/src/lib.rs | 272 +- gen/reseller1_sandbox/Cargo.toml | 4 +- gen/reseller1_sandbox/README.md | 2 +- gen/reseller1_sandbox/src/cmn.rs | 9 +- gen/reseller1_sandbox/src/lib.rs | 366 +- gen/resourceviews1_beta2/Cargo.toml | 4 +- gen/resourceviews1_beta2/README.md | 2 +- gen/resourceviews1_beta2/src/cmn.rs | 9 +- gen/resourceviews1_beta2/src/lib.rs | 332 +- gen/siteverification1/Cargo.toml | 4 +- gen/siteverification1/README.md | 2 +- gen/siteverification1/src/cmn.rs | 9 +- gen/siteverification1/src/lib.rs | 176 +- gen/spectrum1_explorer/Cargo.toml | 4 +- gen/spectrum1_explorer/README.md | 2 +- gen/spectrum1_explorer/src/cmn.rs | 9 +- gen/spectrum1_explorer/src/lib.rs | 140 +- gen/sqladmin1_beta4/Cargo.toml | 4 +- gen/sqladmin1_beta4/README.md | 2 +- gen/sqladmin1_beta4/src/cmn.rs | 9 +- gen/sqladmin1_beta4/src/lib.rs | 936 ++-- gen/storage1/Cargo.toml | 4 +- gen/storage1/README.md | 2 +- gen/storage1/src/cmn.rs | 9 +- gen/storage1/src/lib.rs | 1074 ++-- gen/tagmanager1/Cargo.toml | 4 +- gen/tagmanager1/README.md | 2 +- gen/tagmanager1/src/cmn.rs | 9 +- gen/tagmanager1/src/lib.rs | 1124 ++-- gen/taskqueue1_beta2/Cargo.toml | 4 +- gen/taskqueue1_beta2/README.md | 2 +- gen/taskqueue1_beta2/src/cmn.rs | 9 +- gen/taskqueue1_beta2/src/lib.rs | 248 +- gen/tasks1/Cargo.toml | 4 +- gen/tasks1/README.md | 2 +- gen/tasks1/src/cmn.rs | 9 +- gen/tasks1/src/lib.rs | 374 +- gen/translate2/Cargo.toml | 4 +- gen/translate2/README.md | 2 +- gen/translate2/src/cmn.rs | 9 +- gen/translate2/src/lib.rs | 118 +- gen/urlshortener1/Cargo.toml | 4 +- gen/urlshortener1/README.md | 2 +- gen/urlshortener1/src/cmn.rs | 9 +- gen/urlshortener1/src/lib.rs | 96 +- gen/webfonts1/Cargo.toml | 4 +- gen/webfonts1/README.md | 2 +- gen/webfonts1/src/cmn.rs | 9 +- gen/webfonts1/src/lib.rs | 50 +- gen/webmasters3/Cargo.toml | 4 +- gen/webmasters3/README.md | 2 +- gen/webmasters3/src/cmn.rs | 9 +- gen/webmasters3/src/lib.rs | 336 +- gen/youtube3/README.md | 2 +- gen/youtube3/cargo.toml | 4 +- gen/youtube3/src/cmn.rs | 9 +- gen/youtube3/src/lib.rs | 1620 +++--- gen/youtubeanalytics1/Cargo.toml | 4 +- gen/youtubeanalytics1/README.md | 2 +- gen/youtubeanalytics1/src/cmn.rs | 9 +- gen/youtubeanalytics1/src/lib.rs | 316 +- 313 files changed, 24317 insertions(+), 24707 deletions(-) diff --git a/etc/api/type-api.yaml b/etc/api/type-api.yaml index 05bf9c13202..320a2868a75 100644 --- a/etc/api/type-api.yaml +++ b/etc/api/type-api.yaml @@ -26,7 +26,7 @@ make: - source: lib.rs output_dir: src cargo: - build_version: "0.1.4" + build_version: "0.1.5" keywords: [protocol, web, api] dependencies: - url = "*" diff --git a/gen/adexchangebuyer1d3/Cargo.toml b/gen/adexchangebuyer1d3/Cargo.toml index f35ac0fc496..420df0b45e2 100644 --- a/gen/adexchangebuyer1d3/Cargo.toml +++ b/gen/adexchangebuyer1d3/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-adexchangebuyer1d3" -version = "0.1.4+20150323" +version = "0.1.5+20150323" authors = ["Sebastian Thiel "] description = "A complete library to interact with Ad Exchange Buyer (protocol v1.3)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/adexchangebuyer1d3" homepage = "https://developers.google.com/ad-exchange/buyer-rest" -documentation = "http://byron.github.io/google-apis-rs/google-adexchangebuyer1d3" +documentation = "http://byron.github.io/google-apis-rs/google_adexchangebuyer1d3" license = "MIT" keywords = ["adexchangebuyer", "google", "protocol", "web", "api"] diff --git a/gen/adexchangebuyer1d3/README.md b/gen/adexchangebuyer1d3/README.md index aeb0f50a6af..7a186b11008 100644 --- a/gen/adexchangebuyer1d3/README.md +++ b/gen/adexchangebuyer1d3/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-adexchangebuyer1d3` library allows access to all features of the *Google Ad Exchange Buyer* service. -This documentation was generated from *Ad Exchange Buyer* crate version *0.1.4+20150323*, where *20150323* is the exact revision of the *adexchangebuyer:v1.3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *Ad Exchange Buyer* crate version *0.1.5+20150323*, where *20150323* is the exact revision of the *adexchangebuyer:v1.3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *Ad Exchange Buyer* *v1d3* API can be found at the [official documentation site](https://developers.google.com/ad-exchange/buyer-rest). diff --git a/gen/adexchangebuyer1d3/src/cmn.rs b/gen/adexchangebuyer1d3/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/adexchangebuyer1d3/src/cmn.rs +++ b/gen/adexchangebuyer1d3/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/adexchangebuyer1d3/src/lib.rs b/gen/adexchangebuyer1d3/src/lib.rs index 4befd444edd..83ceedf1824 100644 --- a/gen/adexchangebuyer1d3/src/lib.rs +++ b/gen/adexchangebuyer1d3/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *Ad Exchange Buyer* crate version *0.1.4+20150323*, where *20150323* is the exact revision of the *adexchangebuyer:v1.3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *Ad Exchange Buyer* crate version *0.1.5+20150323*, where *20150323* is the exact revision of the *adexchangebuyer:v1.3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *Ad Exchange Buyer* *v1d3* API can be found at the //! [official documentation site](https://developers.google.com/ad-exchange/buyer-rest). @@ -209,7 +209,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -306,52 +305,49 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct AdExchangeBuyer { +pub struct AdExchangeBuyer { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for AdExchangeBuyer {} +impl<'a, C, A> Hub for AdExchangeBuyer {} -impl<'a, C, NC, A> AdExchangeBuyer - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdExchangeBuyer + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> AdExchangeBuyer { + pub fn new(client: C, authenticator: A) -> AdExchangeBuyer { AdExchangeBuyer { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn accounts(&'a self) -> AccountMethods<'a, C, NC, A> { + pub fn accounts(&'a self) -> AccountMethods<'a, C, A> { AccountMethods { hub: &self } } - pub fn billing_info(&'a self) -> BillingInfoMethods<'a, C, NC, A> { + pub fn billing_info(&'a self) -> BillingInfoMethods<'a, C, A> { BillingInfoMethods { hub: &self } } - pub fn budget(&'a self) -> BudgetMethods<'a, C, NC, A> { + pub fn budget(&'a self) -> BudgetMethods<'a, C, A> { BudgetMethods { hub: &self } } - pub fn creatives(&'a self) -> CreativeMethods<'a, C, NC, A> { + pub fn creatives(&'a self) -> CreativeMethods<'a, C, A> { CreativeMethods { hub: &self } } - pub fn direct_deals(&'a self) -> DirectDealMethods<'a, C, NC, A> { + pub fn direct_deals(&'a self) -> DirectDealMethods<'a, C, A> { DirectDealMethods { hub: &self } } - pub fn performance_report(&'a self) -> PerformanceReportMethods<'a, C, NC, A> { + pub fn performance_report(&'a self) -> PerformanceReportMethods<'a, C, A> { PerformanceReportMethods { hub: &self } } - pub fn pretargeting_config(&'a self) -> PretargetingConfigMethods<'a, C, NC, A> { + pub fn pretargeting_config(&'a self) -> PretargetingConfigMethods<'a, C, A> { PretargetingConfigMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -1030,15 +1026,15 @@ impl Part for AccountBidderLocation {} /// let rb = hub.billing_info(); /// # } /// ``` -pub struct BillingInfoMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BillingInfoMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, } -impl<'a, C, NC, A> MethodsBuilder for BillingInfoMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for BillingInfoMethods<'a, C, A> {} -impl<'a, C, NC, A> BillingInfoMethods<'a, C, NC, A> { +impl<'a, C, A> BillingInfoMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1047,7 +1043,7 @@ impl<'a, C, NC, A> BillingInfoMethods<'a, C, NC, A> { /// # Arguments /// /// * `accountId` - The account id. - pub fn get(&self, account_id: i32) -> BillingInfoGetCall<'a, C, NC, A> { + pub fn get(&self, account_id: i32) -> BillingInfoGetCall<'a, C, A> { BillingInfoGetCall { hub: self.hub, _account_id: account_id, @@ -1060,7 +1056,7 @@ impl<'a, C, NC, A> BillingInfoMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Retrieves a list of billing information for all accounts of the authenticated user. - pub fn list(&self) -> BillingInfoListCall<'a, C, NC, A> { + pub fn list(&self) -> BillingInfoListCall<'a, C, A> { BillingInfoListCall { hub: self.hub, _delegate: Default::default(), @@ -1100,20 +1096,20 @@ impl<'a, C, NC, A> BillingInfoMethods<'a, C, NC, A> { /// let rb = hub.direct_deals(); /// # } /// ``` -pub struct DirectDealMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DirectDealMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, } -impl<'a, C, NC, A> MethodsBuilder for DirectDealMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for DirectDealMethods<'a, C, A> {} -impl<'a, C, NC, A> DirectDealMethods<'a, C, NC, A> { +impl<'a, C, A> DirectDealMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Retrieves the authenticated user's list of direct deals. - pub fn list(&self) -> DirectDealListCall<'a, C, NC, A> { + pub fn list(&self) -> DirectDealListCall<'a, C, A> { DirectDealListCall { hub: self.hub, _delegate: Default::default(), @@ -1129,7 +1125,7 @@ impl<'a, C, NC, A> DirectDealMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The direct deal id - pub fn get(&self, id: &str) -> DirectDealGetCall<'a, C, NC, A> { + pub fn get(&self, id: &str) -> DirectDealGetCall<'a, C, A> { DirectDealGetCall { hub: self.hub, _id: id.to_string(), @@ -1170,15 +1166,15 @@ impl<'a, C, NC, A> DirectDealMethods<'a, C, NC, A> { /// let rb = hub.budget(); /// # } /// ``` -pub struct BudgetMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BudgetMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, } -impl<'a, C, NC, A> MethodsBuilder for BudgetMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for BudgetMethods<'a, C, A> {} -impl<'a, C, NC, A> BudgetMethods<'a, C, NC, A> { +impl<'a, C, A> BudgetMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1189,7 +1185,7 @@ impl<'a, C, NC, A> BudgetMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - The account id associated with the budget being updated. /// * `billingId` - The billing id associated with the budget being updated. - pub fn patch(&self, request: &Budget, account_id: &str, billing_id: &str) -> BudgetPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Budget, account_id: &str, billing_id: &str) -> BudgetPatchCall<'a, C, A> { BudgetPatchCall { hub: self.hub, _request: request.clone(), @@ -1210,7 +1206,7 @@ impl<'a, C, NC, A> BudgetMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - The account id associated with the budget being updated. /// * `billingId` - The billing id associated with the budget being updated. - pub fn update(&self, request: &Budget, account_id: &str, billing_id: &str) -> BudgetUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Budget, account_id: &str, billing_id: &str) -> BudgetUpdateCall<'a, C, A> { BudgetUpdateCall { hub: self.hub, _request: request.clone(), @@ -1230,7 +1226,7 @@ impl<'a, C, NC, A> BudgetMethods<'a, C, NC, A> { /// /// * `accountId` - The account id to get the budget information for. /// * `billingId` - The billing id to get the budget information for. - pub fn get(&self, account_id: &str, billing_id: &str) -> BudgetGetCall<'a, C, NC, A> { + pub fn get(&self, account_id: &str, billing_id: &str) -> BudgetGetCall<'a, C, A> { BudgetGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1272,15 +1268,15 @@ impl<'a, C, NC, A> BudgetMethods<'a, C, NC, A> { /// let rb = hub.creatives(); /// # } /// ``` -pub struct CreativeMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, } -impl<'a, C, NC, A> MethodsBuilder for CreativeMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CreativeMethods<'a, C, A> {} -impl<'a, C, NC, A> CreativeMethods<'a, C, NC, A> { +impl<'a, C, A> CreativeMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1289,7 +1285,7 @@ impl<'a, C, NC, A> CreativeMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &Creative) -> CreativeInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Creative) -> CreativeInsertCall<'a, C, A> { CreativeInsertCall { hub: self.hub, _request: request.clone(), @@ -1302,7 +1298,7 @@ impl<'a, C, NC, A> CreativeMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Retrieves a list of the authenticated user's active creatives. A creative will be available 30-40 minutes after submission. - pub fn list(&self) -> CreativeListCall<'a, C, NC, A> { + pub fn list(&self) -> CreativeListCall<'a, C, A> { CreativeListCall { hub: self.hub, _status_filter: Default::default(), @@ -1324,7 +1320,7 @@ impl<'a, C, NC, A> CreativeMethods<'a, C, NC, A> { /// /// * `accountId` - The id for the account that will serve this creative. /// * `buyerCreativeId` - The buyer-specific id for this creative. - pub fn get(&self, account_id: i32, buyer_creative_id: &str) -> CreativeGetCall<'a, C, NC, A> { + pub fn get(&self, account_id: i32, buyer_creative_id: &str) -> CreativeGetCall<'a, C, A> { CreativeGetCall { hub: self.hub, _account_id: account_id, @@ -1366,15 +1362,15 @@ impl<'a, C, NC, A> CreativeMethods<'a, C, NC, A> { /// let rb = hub.accounts(); /// # } /// ``` -pub struct AccountMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, } -impl<'a, C, NC, A> MethodsBuilder for AccountMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AccountMethods<'a, C, A> {} -impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { +impl<'a, C, A> AccountMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1384,7 +1380,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The account id - pub fn update(&self, request: &Account, id: i32) -> AccountUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Account, id: i32) -> AccountUpdateCall<'a, C, A> { AccountUpdateCall { hub: self.hub, _request: request.clone(), @@ -1403,7 +1399,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The account id - pub fn patch(&self, request: &Account, id: i32) -> AccountPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Account, id: i32) -> AccountPatchCall<'a, C, A> { AccountPatchCall { hub: self.hub, _request: request.clone(), @@ -1417,7 +1413,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Retrieves the authenticated user's list of accounts. - pub fn list(&self) -> AccountListCall<'a, C, NC, A> { + pub fn list(&self) -> AccountListCall<'a, C, A> { AccountListCall { hub: self.hub, _delegate: Default::default(), @@ -1433,7 +1429,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The account id - pub fn get(&self, id: i32) -> AccountGetCall<'a, C, NC, A> { + pub fn get(&self, id: i32) -> AccountGetCall<'a, C, A> { AccountGetCall { hub: self.hub, _id: id, @@ -1474,15 +1470,15 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// let rb = hub.performance_report(); /// # } /// ``` -pub struct PerformanceReportMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PerformanceReportMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, } -impl<'a, C, NC, A> MethodsBuilder for PerformanceReportMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PerformanceReportMethods<'a, C, A> {} -impl<'a, C, NC, A> PerformanceReportMethods<'a, C, NC, A> { +impl<'a, C, A> PerformanceReportMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1493,7 +1489,7 @@ impl<'a, C, NC, A> PerformanceReportMethods<'a, C, NC, A> { /// * `accountId` - The account id to get the reports. /// * `endDateTime` - The end time of the report in ISO 8601 timestamp format using UTC. /// * `startDateTime` - The start time of the report in ISO 8601 timestamp format using UTC. - pub fn list(&self, account_id: &str, end_date_time: &str, start_date_time: &str) -> PerformanceReportListCall<'a, C, NC, A> { + pub fn list(&self, account_id: &str, end_date_time: &str, start_date_time: &str) -> PerformanceReportListCall<'a, C, A> { PerformanceReportListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1538,15 +1534,15 @@ impl<'a, C, NC, A> PerformanceReportMethods<'a, C, NC, A> { /// let rb = hub.pretargeting_config(); /// # } /// ``` -pub struct PretargetingConfigMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PretargetingConfigMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, } -impl<'a, C, NC, A> MethodsBuilder for PretargetingConfigMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PretargetingConfigMethods<'a, C, A> {} -impl<'a, C, NC, A> PretargetingConfigMethods<'a, C, NC, A> { +impl<'a, C, A> PretargetingConfigMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1556,7 +1552,7 @@ impl<'a, C, NC, A> PretargetingConfigMethods<'a, C, NC, A> { /// /// * `accountId` - The account id to delete the pretargeting config for. /// * `configId` - The specific id of the configuration to delete. - pub fn delete(&self, account_id: &str, config_id: &str) -> PretargetingConfigDeleteCall<'a, C, NC, A> { + pub fn delete(&self, account_id: &str, config_id: &str) -> PretargetingConfigDeleteCall<'a, C, A> { PretargetingConfigDeleteCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1576,7 +1572,7 @@ impl<'a, C, NC, A> PretargetingConfigMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - The account id to update the pretargeting config for. /// * `configId` - The specific id of the configuration to update. - pub fn patch(&self, request: &PretargetingConfig, account_id: &str, config_id: &str) -> PretargetingConfigPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &PretargetingConfig, account_id: &str, config_id: &str) -> PretargetingConfigPatchCall<'a, C, A> { PretargetingConfigPatchCall { hub: self.hub, _request: request.clone(), @@ -1596,7 +1592,7 @@ impl<'a, C, NC, A> PretargetingConfigMethods<'a, C, NC, A> { /// /// * `accountId` - The account id to get the pretargeting config for. /// * `configId` - The specific id of the configuration to retrieve. - pub fn get(&self, account_id: &str, config_id: &str) -> PretargetingConfigGetCall<'a, C, NC, A> { + pub fn get(&self, account_id: &str, config_id: &str) -> PretargetingConfigGetCall<'a, C, A> { PretargetingConfigGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1615,7 +1611,7 @@ impl<'a, C, NC, A> PretargetingConfigMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `accountId` - The account id to insert the pretargeting config for. - pub fn insert(&self, request: &PretargetingConfig, account_id: &str) -> PretargetingConfigInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &PretargetingConfig, account_id: &str) -> PretargetingConfigInsertCall<'a, C, A> { PretargetingConfigInsertCall { hub: self.hub, _request: request.clone(), @@ -1633,7 +1629,7 @@ impl<'a, C, NC, A> PretargetingConfigMethods<'a, C, NC, A> { /// # Arguments /// /// * `accountId` - The account id to get the pretargeting configs for. - pub fn list(&self, account_id: &str) -> PretargetingConfigListCall<'a, C, NC, A> { + pub fn list(&self, account_id: &str) -> PretargetingConfigListCall<'a, C, A> { PretargetingConfigListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1652,7 +1648,7 @@ impl<'a, C, NC, A> PretargetingConfigMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - The account id to update the pretargeting config for. /// * `configId` - The specific id of the configuration to update. - pub fn update(&self, request: &PretargetingConfig, account_id: &str, config_id: &str) -> PretargetingConfigUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &PretargetingConfig, account_id: &str, config_id: &str) -> PretargetingConfigUpdateCall<'a, C, A> { PretargetingConfigUpdateCall { hub: self.hub, _request: request.clone(), @@ -1703,19 +1699,19 @@ impl<'a, C, NC, A> PretargetingConfigMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct BillingInfoGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BillingInfoGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, _account_id: i32, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BillingInfoGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BillingInfoGetCall<'a, C, A> {} -impl<'a, C, NC, A> BillingInfoGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BillingInfoGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1847,7 +1843,7 @@ impl<'a, C, NC, A> BillingInfoGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The account id. - pub fn account_id(mut self, new_value: i32) -> BillingInfoGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: i32) -> BillingInfoGetCall<'a, C, A> { self._account_id = new_value; self } @@ -1858,7 +1854,7 @@ impl<'a, C, NC, A> BillingInfoGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BillingInfoGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BillingInfoGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1879,7 +1875,7 @@ impl<'a, C, NC, A> BillingInfoGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BillingInfoGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BillingInfoGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1896,7 +1892,7 @@ impl<'a, C, NC, A> BillingInfoGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BillingInfoGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BillingInfoGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1934,18 +1930,18 @@ impl<'a, C, NC, A> BillingInfoGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct BillingInfoListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BillingInfoListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BillingInfoListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BillingInfoListCall<'a, C, A> {} -impl<'a, C, NC, A> BillingInfoListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BillingInfoListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2053,7 +2049,7 @@ impl<'a, C, NC, A> BillingInfoListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BillingInfoListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BillingInfoListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2074,7 +2070,7 @@ impl<'a, C, NC, A> BillingInfoListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BillingInfoListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BillingInfoListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2091,7 +2087,7 @@ impl<'a, C, NC, A> BillingInfoListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BillingInfoListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BillingInfoListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2129,18 +2125,18 @@ impl<'a, C, NC, A> BillingInfoListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct DirectDealListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DirectDealListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DirectDealListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DirectDealListCall<'a, C, A> {} -impl<'a, C, NC, A> DirectDealListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DirectDealListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2248,7 +2244,7 @@ impl<'a, C, NC, A> DirectDealListCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DirectDealListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DirectDealListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2269,7 +2265,7 @@ impl<'a, C, NC, A> DirectDealListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DirectDealListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DirectDealListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2286,7 +2282,7 @@ impl<'a, C, NC, A> DirectDealListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DirectDealListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DirectDealListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2324,19 +2320,19 @@ impl<'a, C, NC, A> DirectDealListCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct DirectDealGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DirectDealGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DirectDealGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DirectDealGetCall<'a, C, A> {} -impl<'a, C, NC, A> DirectDealGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DirectDealGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2468,7 +2464,7 @@ impl<'a, C, NC, A> DirectDealGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The direct deal id - pub fn id(mut self, new_value: &str) -> DirectDealGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> DirectDealGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -2479,7 +2475,7 @@ impl<'a, C, NC, A> DirectDealGetCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DirectDealGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DirectDealGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2500,7 +2496,7 @@ impl<'a, C, NC, A> DirectDealGetCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DirectDealGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DirectDealGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2517,7 +2513,7 @@ impl<'a, C, NC, A> DirectDealGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DirectDealGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DirectDealGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2561,10 +2557,10 @@ impl<'a, C, NC, A> DirectDealGetCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct BudgetPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BudgetPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, _request: Budget, _account_id: String, _billing_id: String, @@ -2573,9 +2569,9 @@ pub struct BudgetPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BudgetPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BudgetPatchCall<'a, C, A> {} -impl<'a, C, NC, A> BudgetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BudgetPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2715,7 +2711,7 @@ impl<'a, C, NC, A> BudgetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Budget) -> BudgetPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Budget) -> BudgetPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2725,7 +2721,7 @@ impl<'a, C, NC, A> BudgetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The account id associated with the budget being updated. - pub fn account_id(mut self, new_value: &str) -> BudgetPatchCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> BudgetPatchCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -2735,7 +2731,7 @@ impl<'a, C, NC, A> BudgetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The billing id associated with the budget being updated. - pub fn billing_id(mut self, new_value: &str) -> BudgetPatchCall<'a, C, NC, A> { + pub fn billing_id(mut self, new_value: &str) -> BudgetPatchCall<'a, C, A> { self._billing_id = new_value.to_string(); self } @@ -2746,7 +2742,7 @@ impl<'a, C, NC, A> BudgetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BudgetPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BudgetPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2767,7 +2763,7 @@ impl<'a, C, NC, A> BudgetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BudgetPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BudgetPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2784,7 +2780,7 @@ impl<'a, C, NC, A> BudgetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BudgetPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BudgetPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2828,10 +2824,10 @@ impl<'a, C, NC, A> BudgetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct BudgetUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BudgetUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, _request: Budget, _account_id: String, _billing_id: String, @@ -2840,9 +2836,9 @@ pub struct BudgetUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BudgetUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BudgetUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> BudgetUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BudgetUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2982,7 +2978,7 @@ impl<'a, C, NC, A> BudgetUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Budget) -> BudgetUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Budget) -> BudgetUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2992,7 +2988,7 @@ impl<'a, C, NC, A> BudgetUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The account id associated with the budget being updated. - pub fn account_id(mut self, new_value: &str) -> BudgetUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> BudgetUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -3002,7 +2998,7 @@ impl<'a, C, NC, A> BudgetUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The billing id associated with the budget being updated. - pub fn billing_id(mut self, new_value: &str) -> BudgetUpdateCall<'a, C, NC, A> { + pub fn billing_id(mut self, new_value: &str) -> BudgetUpdateCall<'a, C, A> { self._billing_id = new_value.to_string(); self } @@ -3013,7 +3009,7 @@ impl<'a, C, NC, A> BudgetUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BudgetUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BudgetUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3034,7 +3030,7 @@ impl<'a, C, NC, A> BudgetUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BudgetUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BudgetUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3051,7 +3047,7 @@ impl<'a, C, NC, A> BudgetUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BudgetUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BudgetUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3089,10 +3085,10 @@ impl<'a, C, NC, A> BudgetUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct BudgetGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BudgetGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, _account_id: String, _billing_id: String, _delegate: Option<&'a mut Delegate>, @@ -3100,9 +3096,9 @@ pub struct BudgetGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BudgetGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BudgetGetCall<'a, C, A> {} -impl<'a, C, NC, A> BudgetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BudgetGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3235,7 +3231,7 @@ impl<'a, C, NC, A> BudgetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The account id to get the budget information for. - pub fn account_id(mut self, new_value: &str) -> BudgetGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> BudgetGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -3245,7 +3241,7 @@ impl<'a, C, NC, A> BudgetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The billing id to get the budget information for. - pub fn billing_id(mut self, new_value: &str) -> BudgetGetCall<'a, C, NC, A> { + pub fn billing_id(mut self, new_value: &str) -> BudgetGetCall<'a, C, A> { self._billing_id = new_value.to_string(); self } @@ -3256,7 +3252,7 @@ impl<'a, C, NC, A> BudgetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BudgetGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BudgetGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3277,7 +3273,7 @@ impl<'a, C, NC, A> BudgetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BudgetGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BudgetGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3294,7 +3290,7 @@ impl<'a, C, NC, A> BudgetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BudgetGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BudgetGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3338,19 +3334,19 @@ impl<'a, C, NC, A> BudgetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct CreativeInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, _request: Creative, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeInsertCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3464,7 +3460,7 @@ impl<'a, C, NC, A> CreativeInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Creative) -> CreativeInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Creative) -> CreativeInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3475,7 +3471,7 @@ impl<'a, C, NC, A> CreativeInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3496,7 +3492,7 @@ impl<'a, C, NC, A> CreativeInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3513,7 +3509,7 @@ impl<'a, C, NC, A> CreativeInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3556,10 +3552,10 @@ impl<'a, C, NC, A> CreativeInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct CreativeListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, _status_filter: Option, _page_token: Option, _max_results: Option, @@ -3570,9 +3566,9 @@ pub struct CreativeListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeListCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3700,7 +3696,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// When specified, only creatives having the given status are returned. - pub fn status_filter(mut self, new_value: &str) -> CreativeListCall<'a, C, NC, A> { + pub fn status_filter(mut self, new_value: &str) -> CreativeListCall<'a, C, A> { self._status_filter = Some(new_value.to_string()); self } @@ -3708,7 +3704,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// A continuation token, used to page through ad clients. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. Optional. - pub fn page_token(mut self, new_value: &str) -> CreativeListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> CreativeListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -3716,7 +3712,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Maximum number of entries returned on one result page. If not set, the default is 100. Optional. - pub fn max_results(mut self, new_value: u32) -> CreativeListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> CreativeListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -3725,7 +3721,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// When specified, only creatives for the given buyer creative ids are returned. - pub fn add_buyer_creative_id(mut self, new_value: &str) -> CreativeListCall<'a, C, NC, A> { + pub fn add_buyer_creative_id(mut self, new_value: &str) -> CreativeListCall<'a, C, A> { self._buyer_creative_id.push(new_value.to_string()); self } @@ -3734,7 +3730,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// When specified, only creatives for the given account ids are returned. - pub fn add_account_id(mut self, new_value: i32) -> CreativeListCall<'a, C, NC, A> { + pub fn add_account_id(mut self, new_value: i32) -> CreativeListCall<'a, C, A> { self._account_id.push(new_value); self } @@ -3745,7 +3741,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3766,7 +3762,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3783,7 +3779,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3821,10 +3817,10 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct CreativeGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, _account_id: i32, _buyer_creative_id: String, _delegate: Option<&'a mut Delegate>, @@ -3832,9 +3828,9 @@ pub struct CreativeGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeGetCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3967,7 +3963,7 @@ impl<'a, C, NC, A> CreativeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The id for the account that will serve this creative. - pub fn account_id(mut self, new_value: i32) -> CreativeGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: i32) -> CreativeGetCall<'a, C, A> { self._account_id = new_value; self } @@ -3977,7 +3973,7 @@ impl<'a, C, NC, A> CreativeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The buyer-specific id for this creative. - pub fn buyer_creative_id(mut self, new_value: &str) -> CreativeGetCall<'a, C, NC, A> { + pub fn buyer_creative_id(mut self, new_value: &str) -> CreativeGetCall<'a, C, A> { self._buyer_creative_id = new_value.to_string(); self } @@ -3988,7 +3984,7 @@ impl<'a, C, NC, A> CreativeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4009,7 +4005,7 @@ impl<'a, C, NC, A> CreativeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4026,7 +4022,7 @@ impl<'a, C, NC, A> CreativeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4070,10 +4066,10 @@ impl<'a, C, NC, A> CreativeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct AccountUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, _request: Account, _id: i32, _delegate: Option<&'a mut Delegate>, @@ -4081,9 +4077,9 @@ pub struct AccountUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4222,7 +4218,7 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Account) -> AccountUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Account) -> AccountUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4232,7 +4228,7 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The account id - pub fn id(mut self, new_value: i32) -> AccountUpdateCall<'a, C, NC, A> { + pub fn id(mut self, new_value: i32) -> AccountUpdateCall<'a, C, A> { self._id = new_value; self } @@ -4243,7 +4239,7 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4264,7 +4260,7 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4281,7 +4277,7 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4325,10 +4321,10 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct AccountPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, _request: Account, _id: i32, _delegate: Option<&'a mut Delegate>, @@ -4336,9 +4332,9 @@ pub struct AccountPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountPatchCall<'a, C, A> {} -impl<'a, C, NC, A> AccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4477,7 +4473,7 @@ impl<'a, C, NC, A> AccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Account) -> AccountPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Account) -> AccountPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4487,7 +4483,7 @@ impl<'a, C, NC, A> AccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The account id - pub fn id(mut self, new_value: i32) -> AccountPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: i32) -> AccountPatchCall<'a, C, A> { self._id = new_value; self } @@ -4498,7 +4494,7 @@ impl<'a, C, NC, A> AccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4519,7 +4515,7 @@ impl<'a, C, NC, A> AccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4536,7 +4532,7 @@ impl<'a, C, NC, A> AccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4574,18 +4570,18 @@ impl<'a, C, NC, A> AccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct AccountListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4693,7 +4689,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4714,7 +4710,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4731,7 +4727,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4769,19 +4765,19 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct AccountGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, _id: i32, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4913,7 +4909,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The account id - pub fn id(mut self, new_value: i32) -> AccountGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: i32) -> AccountGetCall<'a, C, A> { self._id = new_value; self } @@ -4924,7 +4920,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4945,7 +4941,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4962,7 +4958,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5002,10 +4998,10 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct PerformanceReportListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PerformanceReportListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, _account_id: String, _end_date_time: String, _start_date_time: String, @@ -5016,9 +5012,9 @@ pub struct PerformanceReportListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PerformanceReportListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PerformanceReportListCall<'a, C, A> {} -impl<'a, C, NC, A> PerformanceReportListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PerformanceReportListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5134,7 +5130,7 @@ impl<'a, C, NC, A> PerformanceReportListCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The account id to get the reports. - pub fn account_id(mut self, new_value: &str) -> PerformanceReportListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> PerformanceReportListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -5144,7 +5140,7 @@ impl<'a, C, NC, A> PerformanceReportListCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The end time of the report in ISO 8601 timestamp format using UTC. - pub fn end_date_time(mut self, new_value: &str) -> PerformanceReportListCall<'a, C, NC, A> { + pub fn end_date_time(mut self, new_value: &str) -> PerformanceReportListCall<'a, C, A> { self._end_date_time = new_value.to_string(); self } @@ -5154,7 +5150,7 @@ impl<'a, C, NC, A> PerformanceReportListCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The start time of the report in ISO 8601 timestamp format using UTC. - pub fn start_date_time(mut self, new_value: &str) -> PerformanceReportListCall<'a, C, NC, A> { + pub fn start_date_time(mut self, new_value: &str) -> PerformanceReportListCall<'a, C, A> { self._start_date_time = new_value.to_string(); self } @@ -5162,7 +5158,7 @@ impl<'a, C, NC, A> PerformanceReportListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// A continuation token, used to page through performance reports. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. Optional. - pub fn page_token(mut self, new_value: &str) -> PerformanceReportListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> PerformanceReportListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -5170,7 +5166,7 @@ impl<'a, C, NC, A> PerformanceReportListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Maximum number of entries returned on one result page. If not set, the default is 100. Optional. - pub fn max_results(mut self, new_value: u32) -> PerformanceReportListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> PerformanceReportListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -5181,7 +5177,7 @@ impl<'a, C, NC, A> PerformanceReportListCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PerformanceReportListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PerformanceReportListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5202,7 +5198,7 @@ impl<'a, C, NC, A> PerformanceReportListCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PerformanceReportListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PerformanceReportListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5219,7 +5215,7 @@ impl<'a, C, NC, A> PerformanceReportListCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PerformanceReportListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PerformanceReportListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5257,10 +5253,10 @@ impl<'a, C, NC, A> PerformanceReportListCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct PretargetingConfigDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PretargetingConfigDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, _account_id: String, _config_id: String, _delegate: Option<&'a mut Delegate>, @@ -5268,9 +5264,9 @@ pub struct PretargetingConfigDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PretargetingConfigDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PretargetingConfigDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> PretargetingConfigDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PretargetingConfigDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5392,7 +5388,7 @@ impl<'a, C, NC, A> PretargetingConfigDeleteCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The account id to delete the pretargeting config for. - pub fn account_id(mut self, new_value: &str) -> PretargetingConfigDeleteCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> PretargetingConfigDeleteCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -5402,7 +5398,7 @@ impl<'a, C, NC, A> PretargetingConfigDeleteCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The specific id of the configuration to delete. - pub fn config_id(mut self, new_value: &str) -> PretargetingConfigDeleteCall<'a, C, NC, A> { + pub fn config_id(mut self, new_value: &str) -> PretargetingConfigDeleteCall<'a, C, A> { self._config_id = new_value.to_string(); self } @@ -5413,7 +5409,7 @@ impl<'a, C, NC, A> PretargetingConfigDeleteCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PretargetingConfigDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PretargetingConfigDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5434,7 +5430,7 @@ impl<'a, C, NC, A> PretargetingConfigDeleteCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PretargetingConfigDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PretargetingConfigDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5451,7 +5447,7 @@ impl<'a, C, NC, A> PretargetingConfigDeleteCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PretargetingConfigDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PretargetingConfigDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5495,10 +5491,10 @@ impl<'a, C, NC, A> PretargetingConfigDeleteCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct PretargetingConfigPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PretargetingConfigPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, _request: PretargetingConfig, _account_id: String, _config_id: String, @@ -5507,9 +5503,9 @@ pub struct PretargetingConfigPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PretargetingConfigPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PretargetingConfigPatchCall<'a, C, A> {} -impl<'a, C, NC, A> PretargetingConfigPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PretargetingConfigPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5649,7 +5645,7 @@ impl<'a, C, NC, A> PretargetingConfigPatchCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PretargetingConfig) -> PretargetingConfigPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PretargetingConfig) -> PretargetingConfigPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5659,7 +5655,7 @@ impl<'a, C, NC, A> PretargetingConfigPatchCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The account id to update the pretargeting config for. - pub fn account_id(mut self, new_value: &str) -> PretargetingConfigPatchCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> PretargetingConfigPatchCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -5669,7 +5665,7 @@ impl<'a, C, NC, A> PretargetingConfigPatchCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The specific id of the configuration to update. - pub fn config_id(mut self, new_value: &str) -> PretargetingConfigPatchCall<'a, C, NC, A> { + pub fn config_id(mut self, new_value: &str) -> PretargetingConfigPatchCall<'a, C, A> { self._config_id = new_value.to_string(); self } @@ -5680,7 +5676,7 @@ impl<'a, C, NC, A> PretargetingConfigPatchCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PretargetingConfigPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PretargetingConfigPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5701,7 +5697,7 @@ impl<'a, C, NC, A> PretargetingConfigPatchCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PretargetingConfigPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PretargetingConfigPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5718,7 +5714,7 @@ impl<'a, C, NC, A> PretargetingConfigPatchCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PretargetingConfigPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PretargetingConfigPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5756,10 +5752,10 @@ impl<'a, C, NC, A> PretargetingConfigPatchCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct PretargetingConfigGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PretargetingConfigGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, _account_id: String, _config_id: String, _delegate: Option<&'a mut Delegate>, @@ -5767,9 +5763,9 @@ pub struct PretargetingConfigGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PretargetingConfigGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PretargetingConfigGetCall<'a, C, A> {} -impl<'a, C, NC, A> PretargetingConfigGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PretargetingConfigGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5902,7 +5898,7 @@ impl<'a, C, NC, A> PretargetingConfigGetCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The account id to get the pretargeting config for. - pub fn account_id(mut self, new_value: &str) -> PretargetingConfigGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> PretargetingConfigGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -5912,7 +5908,7 @@ impl<'a, C, NC, A> PretargetingConfigGetCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The specific id of the configuration to retrieve. - pub fn config_id(mut self, new_value: &str) -> PretargetingConfigGetCall<'a, C, NC, A> { + pub fn config_id(mut self, new_value: &str) -> PretargetingConfigGetCall<'a, C, A> { self._config_id = new_value.to_string(); self } @@ -5923,7 +5919,7 @@ impl<'a, C, NC, A> PretargetingConfigGetCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PretargetingConfigGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PretargetingConfigGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5944,7 +5940,7 @@ impl<'a, C, NC, A> PretargetingConfigGetCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PretargetingConfigGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PretargetingConfigGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5961,7 +5957,7 @@ impl<'a, C, NC, A> PretargetingConfigGetCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PretargetingConfigGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PretargetingConfigGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6005,10 +6001,10 @@ impl<'a, C, NC, A> PretargetingConfigGetCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct PretargetingConfigInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PretargetingConfigInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, _request: PretargetingConfig, _account_id: String, _delegate: Option<&'a mut Delegate>, @@ -6016,9 +6012,9 @@ pub struct PretargetingConfigInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PretargetingConfigInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PretargetingConfigInsertCall<'a, C, A> {} -impl<'a, C, NC, A> PretargetingConfigInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PretargetingConfigInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6157,7 +6153,7 @@ impl<'a, C, NC, A> PretargetingConfigInsertCall<'a, C, NC, A> where NC: hyper::n /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PretargetingConfig) -> PretargetingConfigInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PretargetingConfig) -> PretargetingConfigInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6167,7 +6163,7 @@ impl<'a, C, NC, A> PretargetingConfigInsertCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The account id to insert the pretargeting config for. - pub fn account_id(mut self, new_value: &str) -> PretargetingConfigInsertCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> PretargetingConfigInsertCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -6178,7 +6174,7 @@ impl<'a, C, NC, A> PretargetingConfigInsertCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PretargetingConfigInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PretargetingConfigInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6199,7 +6195,7 @@ impl<'a, C, NC, A> PretargetingConfigInsertCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PretargetingConfigInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PretargetingConfigInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6216,7 +6212,7 @@ impl<'a, C, NC, A> PretargetingConfigInsertCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PretargetingConfigInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PretargetingConfigInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6254,19 +6250,19 @@ impl<'a, C, NC, A> PretargetingConfigInsertCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct PretargetingConfigListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PretargetingConfigListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, _account_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PretargetingConfigListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PretargetingConfigListCall<'a, C, A> {} -impl<'a, C, NC, A> PretargetingConfigListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PretargetingConfigListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6398,7 +6394,7 @@ impl<'a, C, NC, A> PretargetingConfigListCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The account id to get the pretargeting configs for. - pub fn account_id(mut self, new_value: &str) -> PretargetingConfigListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> PretargetingConfigListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -6409,7 +6405,7 @@ impl<'a, C, NC, A> PretargetingConfigListCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PretargetingConfigListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PretargetingConfigListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6430,7 +6426,7 @@ impl<'a, C, NC, A> PretargetingConfigListCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PretargetingConfigListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PretargetingConfigListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6447,7 +6443,7 @@ impl<'a, C, NC, A> PretargetingConfigListCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PretargetingConfigListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PretargetingConfigListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6491,10 +6487,10 @@ impl<'a, C, NC, A> PretargetingConfigListCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct PretargetingConfigUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PretargetingConfigUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeBuyer, + hub: &'a AdExchangeBuyer, _request: PretargetingConfig, _account_id: String, _config_id: String, @@ -6503,9 +6499,9 @@ pub struct PretargetingConfigUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PretargetingConfigUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PretargetingConfigUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> PretargetingConfigUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PretargetingConfigUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6645,7 +6641,7 @@ impl<'a, C, NC, A> PretargetingConfigUpdateCall<'a, C, NC, A> where NC: hyper::n /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PretargetingConfig) -> PretargetingConfigUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PretargetingConfig) -> PretargetingConfigUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6655,7 +6651,7 @@ impl<'a, C, NC, A> PretargetingConfigUpdateCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The account id to update the pretargeting config for. - pub fn account_id(mut self, new_value: &str) -> PretargetingConfigUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> PretargetingConfigUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -6665,7 +6661,7 @@ impl<'a, C, NC, A> PretargetingConfigUpdateCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The specific id of the configuration to update. - pub fn config_id(mut self, new_value: &str) -> PretargetingConfigUpdateCall<'a, C, NC, A> { + pub fn config_id(mut self, new_value: &str) -> PretargetingConfigUpdateCall<'a, C, A> { self._config_id = new_value.to_string(); self } @@ -6676,7 +6672,7 @@ impl<'a, C, NC, A> PretargetingConfigUpdateCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PretargetingConfigUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PretargetingConfigUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6697,7 +6693,7 @@ impl<'a, C, NC, A> PretargetingConfigUpdateCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PretargetingConfigUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PretargetingConfigUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6714,7 +6710,7 @@ impl<'a, C, NC, A> PretargetingConfigUpdateCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PretargetingConfigUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PretargetingConfigUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/adexchangeseller2/Cargo.toml b/gen/adexchangeseller2/Cargo.toml index 6208dc42827..4e67c0f19ea 100644 --- a/gen/adexchangeseller2/Cargo.toml +++ b/gen/adexchangeseller2/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-adexchangeseller2" -version = "0.1.4+20150326" +version = "0.1.5+20150326" authors = ["Sebastian Thiel "] description = "A complete library to interact with Ad Exchange Seller (protocol v2.0)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/adexchangeseller2" homepage = "https://developers.google.com/ad-exchange/seller-rest/" -documentation = "http://byron.github.io/google-apis-rs/google-adexchangeseller2" +documentation = "http://byron.github.io/google-apis-rs/google_adexchangeseller2" license = "MIT" keywords = ["adexchangeseller", "google", "protocol", "web", "api"] diff --git a/gen/adexchangeseller2/README.md b/gen/adexchangeseller2/README.md index 4b11629ca37..56eb6960e8c 100644 --- a/gen/adexchangeseller2/README.md +++ b/gen/adexchangeseller2/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-adexchangeseller2` library allows access to all features of the *Google Ad Exchange Seller* service. -This documentation was generated from *Ad Exchange Seller* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *adexchangeseller:v2.0* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *Ad Exchange Seller* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *adexchangeseller:v2.0* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *Ad Exchange Seller* *v2* API can be found at the [official documentation site](https://developers.google.com/ad-exchange/seller-rest/). diff --git a/gen/adexchangeseller2/src/cmn.rs b/gen/adexchangeseller2/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/adexchangeseller2/src/cmn.rs +++ b/gen/adexchangeseller2/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/adexchangeseller2/src/lib.rs b/gen/adexchangeseller2/src/lib.rs index 46cfb5f2fae..10fbb115e88 100644 --- a/gen/adexchangeseller2/src/lib.rs +++ b/gen/adexchangeseller2/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *Ad Exchange Seller* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *adexchangeseller:v2.0* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *Ad Exchange Seller* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *adexchangeseller:v2.0* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *Ad Exchange Seller* *v2* API can be found at the //! [official documentation site](https://developers.google.com/ad-exchange/seller-rest/). @@ -212,7 +212,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -314,34 +313,31 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct AdExchangeSeller { +pub struct AdExchangeSeller { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for AdExchangeSeller {} +impl<'a, C, A> Hub for AdExchangeSeller {} -impl<'a, C, NC, A> AdExchangeSeller - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdExchangeSeller + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> AdExchangeSeller { + pub fn new(client: C, authenticator: A) -> AdExchangeSeller { AdExchangeSeller { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn accounts(&'a self) -> AccountMethods<'a, C, NC, A> { + pub fn accounts(&'a self) -> AccountMethods<'a, C, A> { AccountMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -859,15 +855,15 @@ impl ResponseResult for CustomChannel {} /// let rb = hub.accounts(); /// # } /// ``` -pub struct AccountMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeSeller, + hub: &'a AdExchangeSeller, } -impl<'a, C, NC, A> MethodsBuilder for AccountMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AccountMethods<'a, C, A> {} -impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { +impl<'a, C, A> AccountMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -877,7 +873,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `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, C, NC, A> { + pub fn reports_saved_generate(&self, account_id: &str, saved_report_id: &str) -> AccountReportSavedGenerateCall<'a, C, A> { AccountReportSavedGenerateCall { hub: self.hub, _account_id: account_id.to_string(), @@ -898,7 +894,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `accountId` - Account with visibility to the metrics. - pub fn metadata_metrics_list(&self, account_id: &str) -> AccountMetadataMetricListCall<'a, C, NC, A> { + pub fn metadata_metrics_list(&self, account_id: &str) -> AccountMetadataMetricListCall<'a, C, A> { AccountMetadataMetricListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -917,7 +913,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `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, C, NC, A> { + pub fn reports_generate(&self, account_id: &str, start_date: &str, end_date: &str) -> AccountReportGenerateCall<'a, C, A> { AccountReportGenerateCall { hub: self.hub, _account_id: account_id.to_string(), @@ -944,7 +940,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `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, C, NC, A> { + pub fn urlchannels_list(&self, account_id: &str, ad_client_id: &str) -> AccountUrlchannelListCall<'a, C, A> { AccountUrlchannelListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -964,7 +960,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `accountId` - Account owning the saved reports. - pub fn reports_saved_list(&self, account_id: &str) -> AccountReportSavedListCall<'a, C, NC, A> { + pub fn reports_saved_list(&self, account_id: &str) -> AccountReportSavedListCall<'a, C, A> { AccountReportSavedListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -984,7 +980,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `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, C, NC, A> { + pub fn preferreddeals_get(&self, account_id: &str, deal_id: &str) -> AccountPreferreddealGetCall<'a, C, A> { AccountPreferreddealGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1002,7 +998,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `accountId` - Account to which the ad client belongs. - pub fn adclients_list(&self, account_id: &str) -> AccountAdclientListCall<'a, C, NC, A> { + pub fn adclients_list(&self, account_id: &str) -> AccountAdclientListCall<'a, C, A> { AccountAdclientListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1021,7 +1017,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `accountId` - Account with visibility to the dimensions. - pub fn metadata_dimensions_list(&self, account_id: &str) -> AccountMetadataDimensionListCall<'a, C, NC, A> { + pub fn metadata_dimensions_list(&self, account_id: &str) -> AccountMetadataDimensionListCall<'a, C, A> { AccountMetadataDimensionListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1040,7 +1036,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `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, C, NC, A> { + pub fn customchannels_get(&self, account_id: &str, ad_client_id: &str, custom_channel_id: &str) -> AccountCustomchannelGetCall<'a, C, A> { AccountCustomchannelGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1060,7 +1056,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `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, C, NC, A> { + pub fn customchannels_list(&self, account_id: &str, ad_client_id: &str) -> AccountCustomchannelListCall<'a, C, A> { AccountCustomchannelListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1076,7 +1072,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// 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, C, NC, A> { + pub fn list(&self) -> AccountListCall<'a, C, A> { AccountListCall { hub: self.hub, _page_token: Default::default(), @@ -1094,7 +1090,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `accountId` - Account owning the alerts. - pub fn alerts_list(&self, account_id: &str) -> AccountAlertListCall<'a, C, NC, A> { + pub fn alerts_list(&self, account_id: &str) -> AccountAlertListCall<'a, C, A> { AccountAlertListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1112,7 +1108,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `accountId` - Account owning the deals. - pub fn preferreddeals_list(&self, account_id: &str) -> AccountPreferreddealListCall<'a, C, NC, A> { + pub fn preferreddeals_list(&self, account_id: &str) -> AccountPreferreddealListCall<'a, C, A> { AccountPreferreddealListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1129,7 +1125,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `accountId` - Account to get information about. Tip: 'myaccount' is a valid ID. - pub fn get(&self, account_id: &str) -> AccountGetCall<'a, C, NC, A> { + pub fn get(&self, account_id: &str) -> AccountGetCall<'a, C, A> { AccountGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1181,10 +1177,10 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct AccountReportSavedGenerateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountReportSavedGenerateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeSeller, + hub: &'a AdExchangeSeller, _account_id: String, _saved_report_id: String, _start_index: Option, @@ -1195,9 +1191,9 @@ pub struct AccountReportSavedGenerateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountReportSavedGenerateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountReportSavedGenerateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountReportSavedGenerateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountReportSavedGenerateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1339,7 +1335,7 @@ impl<'a, C, NC, A> AccountReportSavedGenerateCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Account owning the saved report. - pub fn account_id(mut self, new_value: &str) -> AccountReportSavedGenerateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountReportSavedGenerateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -1349,7 +1345,7 @@ impl<'a, C, NC, A> AccountReportSavedGenerateCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The saved report to retrieve. - pub fn saved_report_id(mut self, new_value: &str) -> AccountReportSavedGenerateCall<'a, C, NC, A> { + pub fn saved_report_id(mut self, new_value: &str) -> AccountReportSavedGenerateCall<'a, C, A> { self._saved_report_id = new_value.to_string(); self } @@ -1357,7 +1353,7 @@ impl<'a, C, NC, A> AccountReportSavedGenerateCall<'a, C, NC, A> where NC: hyper: /// /// /// Index of the first row of report data to return. - pub fn start_index(mut self, new_value: i32) -> AccountReportSavedGenerateCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> AccountReportSavedGenerateCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -1365,7 +1361,7 @@ impl<'a, C, NC, A> AccountReportSavedGenerateCall<'a, C, NC, A> where NC: hyper: /// /// /// The maximum number of rows of report data to return. - pub fn max_results(mut self, new_value: i32) -> AccountReportSavedGenerateCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AccountReportSavedGenerateCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -1373,7 +1369,7 @@ impl<'a, C, NC, A> AccountReportSavedGenerateCall<'a, C, NC, A> where NC: hyper: /// /// /// Optional locale to use for translating report output to a local language. Defaults to "en_US" if not specified. - pub fn locale(mut self, new_value: &str) -> AccountReportSavedGenerateCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> AccountReportSavedGenerateCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -1384,7 +1380,7 @@ impl<'a, C, NC, A> AccountReportSavedGenerateCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountReportSavedGenerateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountReportSavedGenerateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1405,7 +1401,7 @@ impl<'a, C, NC, A> AccountReportSavedGenerateCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountReportSavedGenerateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountReportSavedGenerateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1422,7 +1418,7 @@ impl<'a, C, NC, A> AccountReportSavedGenerateCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountReportSavedGenerateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountReportSavedGenerateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1460,19 +1456,19 @@ impl<'a, C, NC, A> AccountReportSavedGenerateCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct AccountMetadataMetricListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountMetadataMetricListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeSeller, + hub: &'a AdExchangeSeller, _account_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountMetadataMetricListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountMetadataMetricListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountMetadataMetricListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountMetadataMetricListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1604,7 +1600,7 @@ impl<'a, C, NC, A> AccountMetadataMetricListCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Account with visibility to the metrics. - pub fn account_id(mut self, new_value: &str) -> AccountMetadataMetricListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountMetadataMetricListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -1615,7 +1611,7 @@ impl<'a, C, NC, A> AccountMetadataMetricListCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountMetadataMetricListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountMetadataMetricListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1636,7 +1632,7 @@ impl<'a, C, NC, A> AccountMetadataMetricListCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountMetadataMetricListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountMetadataMetricListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1653,7 +1649,7 @@ impl<'a, C, NC, A> AccountMetadataMetricListCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountMetadataMetricListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountMetadataMetricListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1703,10 +1699,10 @@ impl<'a, C, NC, A> AccountMetadataMetricListCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct AccountReportGenerateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountReportGenerateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeSeller, + hub: &'a AdExchangeSeller, _account_id: String, _start_date: String, _end_date: String, @@ -1722,9 +1718,9 @@ pub struct AccountReportGenerateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountReportGenerateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountReportGenerateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountReportGenerateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1911,7 +1907,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Account which owns the generated report. - pub fn account_id(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -1921,7 +1917,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Start of the date range to report on in "YYYY-MM-DD" format, inclusive. - pub fn start_date(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn start_date(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._start_date = new_value.to_string(); self } @@ -1931,7 +1927,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// End of the date range to report on in "YYYY-MM-DD" format, inclusive. - pub fn end_date(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn end_date(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._end_date = new_value.to_string(); self } @@ -1939,7 +1935,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Index of the first row of report data to return. - pub fn start_index(mut self, new_value: u32) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: u32) -> AccountReportGenerateCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -1948,7 +1944,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// The name of a dimension or metric to sort the resulting report on, optionally prefixed with "+" to sort ascending or "-" to sort descending. If no prefix is specified, the column is sorted ascending. - pub fn add_sort(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn add_sort(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._sort.push(new_value.to_string()); self } @@ -1957,7 +1953,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Numeric columns to include in the report. - pub fn add_metric(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn add_metric(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._metric.push(new_value.to_string()); self } @@ -1965,7 +1961,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// The maximum number of rows of report data to return. - pub fn max_results(mut self, new_value: u32) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> AccountReportGenerateCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -1973,7 +1969,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Optional locale to use for translating report output to a local language. Defaults to "en_US" if not specified. - pub fn locale(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -1982,7 +1978,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Filters to be run on the report. - pub fn add_filter(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn add_filter(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._filter.push(new_value.to_string()); self } @@ -1991,7 +1987,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Dimensions to base the report on. - pub fn add_dimension(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn add_dimension(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._dimension.push(new_value.to_string()); self } @@ -2002,7 +1998,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountReportGenerateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2023,7 +2019,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountReportGenerateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountReportGenerateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2040,7 +2036,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountReportGenerateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountReportGenerateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2080,10 +2076,10 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct AccountUrlchannelListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountUrlchannelListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeSeller, + hub: &'a AdExchangeSeller, _account_id: String, _ad_client_id: String, _page_token: Option, @@ -2093,9 +2089,9 @@ pub struct AccountUrlchannelListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountUrlchannelListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountUrlchannelListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountUrlchannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountUrlchannelListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2234,7 +2230,7 @@ impl<'a, C, NC, A> AccountUrlchannelListCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Account to which the ad client belongs. - pub fn account_id(mut self, new_value: &str) -> AccountUrlchannelListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountUrlchannelListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -2244,7 +2240,7 @@ impl<'a, C, NC, A> AccountUrlchannelListCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Ad client for which to list URL channels. - pub fn ad_client_id(mut self, new_value: &str) -> AccountUrlchannelListCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AccountUrlchannelListCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -2252,7 +2248,7 @@ impl<'a, C, NC, A> AccountUrlchannelListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// A continuation token, used to page through URL channels. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> AccountUrlchannelListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AccountUrlchannelListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2260,7 +2256,7 @@ impl<'a, C, NC, A> AccountUrlchannelListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// The maximum number of URL channels to include in the response, used for paging. - pub fn max_results(mut self, new_value: u32) -> AccountUrlchannelListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> AccountUrlchannelListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2271,7 +2267,7 @@ impl<'a, C, NC, A> AccountUrlchannelListCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountUrlchannelListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountUrlchannelListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2292,7 +2288,7 @@ impl<'a, C, NC, A> AccountUrlchannelListCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountUrlchannelListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountUrlchannelListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2309,7 +2305,7 @@ impl<'a, C, NC, A> AccountUrlchannelListCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountUrlchannelListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountUrlchannelListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2349,10 +2345,10 @@ impl<'a, C, NC, A> AccountUrlchannelListCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct AccountReportSavedListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountReportSavedListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeSeller, + hub: &'a AdExchangeSeller, _account_id: String, _page_token: Option, _max_results: Option, @@ -2361,9 +2357,9 @@ pub struct AccountReportSavedListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountReportSavedListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountReportSavedListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountReportSavedListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountReportSavedListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2501,7 +2497,7 @@ impl<'a, C, NC, A> AccountReportSavedListCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Account owning the saved reports. - pub fn account_id(mut self, new_value: &str) -> AccountReportSavedListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountReportSavedListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -2509,7 +2505,7 @@ impl<'a, C, NC, A> AccountReportSavedListCall<'a, C, NC, A> where NC: hyper::net /// /// /// A continuation token, used to page through saved reports. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> AccountReportSavedListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AccountReportSavedListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2517,7 +2513,7 @@ impl<'a, C, NC, A> AccountReportSavedListCall<'a, C, NC, A> where NC: hyper::net /// /// /// The maximum number of saved reports to include in the response, used for paging. - pub fn max_results(mut self, new_value: i32) -> AccountReportSavedListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AccountReportSavedListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2528,7 +2524,7 @@ impl<'a, C, NC, A> AccountReportSavedListCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountReportSavedListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountReportSavedListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2549,7 +2545,7 @@ impl<'a, C, NC, A> AccountReportSavedListCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountReportSavedListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountReportSavedListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2566,7 +2562,7 @@ impl<'a, C, NC, A> AccountReportSavedListCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountReportSavedListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountReportSavedListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2604,10 +2600,10 @@ impl<'a, C, NC, A> AccountReportSavedListCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct AccountPreferreddealGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountPreferreddealGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeSeller, + hub: &'a AdExchangeSeller, _account_id: String, _deal_id: String, _delegate: Option<&'a mut Delegate>, @@ -2615,9 +2611,9 @@ pub struct AccountPreferreddealGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountPreferreddealGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountPreferreddealGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountPreferreddealGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountPreferreddealGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2750,7 +2746,7 @@ impl<'a, C, NC, A> AccountPreferreddealGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Account owning the deal. - pub fn account_id(mut self, new_value: &str) -> AccountPreferreddealGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountPreferreddealGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -2760,7 +2756,7 @@ impl<'a, C, NC, A> AccountPreferreddealGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Preferred deal to get information about. - pub fn deal_id(mut self, new_value: &str) -> AccountPreferreddealGetCall<'a, C, NC, A> { + pub fn deal_id(mut self, new_value: &str) -> AccountPreferreddealGetCall<'a, C, A> { self._deal_id = new_value.to_string(); self } @@ -2771,7 +2767,7 @@ impl<'a, C, NC, A> AccountPreferreddealGetCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPreferreddealGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPreferreddealGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2792,7 +2788,7 @@ impl<'a, C, NC, A> AccountPreferreddealGetCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountPreferreddealGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountPreferreddealGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2809,7 +2805,7 @@ impl<'a, C, NC, A> AccountPreferreddealGetCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountPreferreddealGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountPreferreddealGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2849,10 +2845,10 @@ impl<'a, C, NC, A> AccountPreferreddealGetCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct AccountAdclientListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountAdclientListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeSeller, + hub: &'a AdExchangeSeller, _account_id: String, _page_token: Option, _max_results: Option, @@ -2861,9 +2857,9 @@ pub struct AccountAdclientListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountAdclientListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountAdclientListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountAdclientListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3001,7 +2997,7 @@ impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Account to which the ad client belongs. - pub fn account_id(mut self, new_value: &str) -> AccountAdclientListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountAdclientListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -3009,7 +3005,7 @@ impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// A continuation token, used to page through ad clients. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> AccountAdclientListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AccountAdclientListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -3017,7 +3013,7 @@ impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The maximum number of ad clients to include in the response, used for paging. - pub fn max_results(mut self, new_value: u32) -> AccountAdclientListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> AccountAdclientListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -3028,7 +3024,7 @@ impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdclientListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdclientListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3049,7 +3045,7 @@ impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountAdclientListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountAdclientListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3066,7 +3062,7 @@ impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountAdclientListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountAdclientListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3104,19 +3100,19 @@ impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct AccountMetadataDimensionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountMetadataDimensionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeSeller, + hub: &'a AdExchangeSeller, _account_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountMetadataDimensionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountMetadataDimensionListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountMetadataDimensionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountMetadataDimensionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3248,7 +3244,7 @@ impl<'a, C, NC, A> AccountMetadataDimensionListCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// Account with visibility to the dimensions. - pub fn account_id(mut self, new_value: &str) -> AccountMetadataDimensionListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountMetadataDimensionListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -3259,7 +3255,7 @@ impl<'a, C, NC, A> AccountMetadataDimensionListCall<'a, C, NC, A> where NC: hype /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountMetadataDimensionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountMetadataDimensionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3280,7 +3276,7 @@ impl<'a, C, NC, A> AccountMetadataDimensionListCall<'a, C, NC, A> where NC: hype /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountMetadataDimensionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountMetadataDimensionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3297,7 +3293,7 @@ impl<'a, C, NC, A> AccountMetadataDimensionListCall<'a, C, NC, A> where NC: hype /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountMetadataDimensionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountMetadataDimensionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3335,10 +3331,10 @@ impl<'a, C, NC, A> AccountMetadataDimensionListCall<'a, C, NC, A> where NC: hype /// .doit(); /// # } /// ``` -pub struct AccountCustomchannelGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountCustomchannelGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeSeller, + hub: &'a AdExchangeSeller, _account_id: String, _ad_client_id: String, _custom_channel_id: String, @@ -3347,9 +3343,9 @@ pub struct AccountCustomchannelGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountCustomchannelGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountCustomchannelGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountCustomchannelGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountCustomchannelGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3483,7 +3479,7 @@ impl<'a, C, NC, A> AccountCustomchannelGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Account to which the ad client belongs. - pub fn account_id(mut self, new_value: &str) -> AccountCustomchannelGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountCustomchannelGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -3493,7 +3489,7 @@ impl<'a, C, NC, A> AccountCustomchannelGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Ad client which contains the custom channel. - pub fn ad_client_id(mut self, new_value: &str) -> AccountCustomchannelGetCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AccountCustomchannelGetCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -3503,7 +3499,7 @@ impl<'a, C, NC, A> AccountCustomchannelGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Custom channel to retrieve. - pub fn custom_channel_id(mut self, new_value: &str) -> AccountCustomchannelGetCall<'a, C, NC, A> { + pub fn custom_channel_id(mut self, new_value: &str) -> AccountCustomchannelGetCall<'a, C, A> { self._custom_channel_id = new_value.to_string(); self } @@ -3514,7 +3510,7 @@ impl<'a, C, NC, A> AccountCustomchannelGetCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountCustomchannelGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountCustomchannelGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3535,7 +3531,7 @@ impl<'a, C, NC, A> AccountCustomchannelGetCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountCustomchannelGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountCustomchannelGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3552,7 +3548,7 @@ impl<'a, C, NC, A> AccountCustomchannelGetCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountCustomchannelGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountCustomchannelGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3592,10 +3588,10 @@ impl<'a, C, NC, A> AccountCustomchannelGetCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct AccountCustomchannelListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountCustomchannelListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeSeller, + hub: &'a AdExchangeSeller, _account_id: String, _ad_client_id: String, _page_token: Option, @@ -3605,9 +3601,9 @@ pub struct AccountCustomchannelListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountCustomchannelListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountCustomchannelListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountCustomchannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountCustomchannelListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3746,7 +3742,7 @@ impl<'a, C, NC, A> AccountCustomchannelListCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Account to which the ad client belongs. - pub fn account_id(mut self, new_value: &str) -> AccountCustomchannelListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountCustomchannelListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -3756,7 +3752,7 @@ impl<'a, C, NC, A> AccountCustomchannelListCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Ad client for which to list custom channels. - pub fn ad_client_id(mut self, new_value: &str) -> AccountCustomchannelListCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AccountCustomchannelListCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -3764,7 +3760,7 @@ impl<'a, C, NC, A> AccountCustomchannelListCall<'a, C, NC, A> where NC: hyper::n /// /// /// A continuation token, used to page through custom channels. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> AccountCustomchannelListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AccountCustomchannelListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -3772,7 +3768,7 @@ impl<'a, C, NC, A> AccountCustomchannelListCall<'a, C, NC, A> where NC: hyper::n /// /// /// The maximum number of custom channels to include in the response, used for paging. - pub fn max_results(mut self, new_value: u32) -> AccountCustomchannelListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> AccountCustomchannelListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -3783,7 +3779,7 @@ impl<'a, C, NC, A> AccountCustomchannelListCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountCustomchannelListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountCustomchannelListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3804,7 +3800,7 @@ impl<'a, C, NC, A> AccountCustomchannelListCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountCustomchannelListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountCustomchannelListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3821,7 +3817,7 @@ impl<'a, C, NC, A> AccountCustomchannelListCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountCustomchannelListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountCustomchannelListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3861,10 +3857,10 @@ impl<'a, C, NC, A> AccountCustomchannelListCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct AccountListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeSeller, + hub: &'a AdExchangeSeller, _page_token: Option, _max_results: Option, _delegate: Option<&'a mut Delegate>, @@ -3872,9 +3868,9 @@ pub struct AccountListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3985,7 +3981,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// A continuation token, used to page through accounts. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> AccountListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AccountListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -3993,7 +3989,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The maximum number of accounts to include in the response, used for paging. - pub fn max_results(mut self, new_value: i32) -> AccountListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AccountListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -4004,7 +4000,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4025,7 +4021,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4042,7 +4038,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4081,10 +4077,10 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct AccountAlertListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountAlertListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeSeller, + hub: &'a AdExchangeSeller, _account_id: String, _locale: Option, _delegate: Option<&'a mut Delegate>, @@ -4092,9 +4088,9 @@ pub struct AccountAlertListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountAlertListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountAlertListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountAlertListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountAlertListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4229,7 +4225,7 @@ impl<'a, C, NC, A> AccountAlertListCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Account owning the alerts. - pub fn account_id(mut self, new_value: &str) -> AccountAlertListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountAlertListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -4237,7 +4233,7 @@ impl<'a, C, NC, A> AccountAlertListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The locale to use for translating alert messages. The account locale will be used if this is not supplied. The AdSense default (English) will be used if the supplied locale is invalid or unsupported. - pub fn locale(mut self, new_value: &str) -> AccountAlertListCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> AccountAlertListCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -4248,7 +4244,7 @@ impl<'a, C, NC, A> AccountAlertListCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAlertListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAlertListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4269,7 +4265,7 @@ impl<'a, C, NC, A> AccountAlertListCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountAlertListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountAlertListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4286,7 +4282,7 @@ impl<'a, C, NC, A> AccountAlertListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountAlertListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountAlertListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4324,19 +4320,19 @@ impl<'a, C, NC, A> AccountAlertListCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct AccountPreferreddealListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountPreferreddealListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeSeller, + hub: &'a AdExchangeSeller, _account_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountPreferreddealListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountPreferreddealListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountPreferreddealListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountPreferreddealListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4468,7 +4464,7 @@ impl<'a, C, NC, A> AccountPreferreddealListCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Account owning the deals. - pub fn account_id(mut self, new_value: &str) -> AccountPreferreddealListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountPreferreddealListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -4479,7 +4475,7 @@ impl<'a, C, NC, A> AccountPreferreddealListCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPreferreddealListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPreferreddealListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4500,7 +4496,7 @@ impl<'a, C, NC, A> AccountPreferreddealListCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountPreferreddealListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountPreferreddealListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4517,7 +4513,7 @@ impl<'a, C, NC, A> AccountPreferreddealListCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountPreferreddealListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountPreferreddealListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4555,19 +4551,19 @@ impl<'a, C, NC, A> AccountPreferreddealListCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct AccountGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdExchangeSeller, + hub: &'a AdExchangeSeller, _account_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4699,7 +4695,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Account to get information about. Tip: 'myaccount' is a valid ID. - pub fn account_id(mut self, new_value: &str) -> AccountGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -4710,7 +4706,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4731,7 +4727,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4748,7 +4744,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/admin1_directory/Cargo.toml b/gen/admin1_directory/Cargo.toml index bd91a315599..5437399d909 100644 --- a/gen/admin1_directory/Cargo.toml +++ b/gen/admin1_directory/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-admin1_directory" -version = "0.1.4+20150309" +version = "0.1.5+20150309" authors = ["Sebastian Thiel "] description = "A complete library to interact with directory (protocol directory_v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/admin1_directory" homepage = "https://developers.google.com/admin-sdk/directory/" -documentation = "http://byron.github.io/google-apis-rs/google-admin1_directory" +documentation = "http://byron.github.io/google-apis-rs/google_admin1_directory" license = "MIT" keywords = ["admin", "google", "protocol", "web", "api"] diff --git a/gen/admin1_directory/README.md b/gen/admin1_directory/README.md index 39b53aa02ca..7956c60d68a 100644 --- a/gen/admin1_directory/README.md +++ b/gen/admin1_directory/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-admin1_directory` library allows access to all features of the *Google directory* service. -This documentation was generated from *directory* crate version *0.1.4+20150309*, where *20150309* is the exact revision of the *admin:directory_v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *directory* crate version *0.1.5+20150309*, where *20150309* is the exact revision of the *admin:directory_v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *directory* *v1_directory* API can be found at the [official documentation site](https://developers.google.com/admin-sdk/directory/). diff --git a/gen/admin1_directory/src/cmn.rs b/gen/admin1_directory/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/admin1_directory/src/cmn.rs +++ b/gen/admin1_directory/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/admin1_directory/src/lib.rs b/gen/admin1_directory/src/lib.rs index 28edb1ba544..57c25dca691 100644 --- a/gen/admin1_directory/src/lib.rs +++ b/gen/admin1_directory/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *directory* crate version *0.1.4+20150309*, where *20150309* is the exact revision of the *admin:directory_v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *directory* crate version *0.1.5+20150309*, where *20150309* is the exact revision of the *admin:directory_v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *directory* *v1_directory* API can be found at the //! [official documentation site](https://developers.google.com/admin-sdk/directory/). @@ -252,7 +252,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -433,67 +432,64 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Directory { +pub struct Directory { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Directory {} +impl<'a, C, A> Hub for Directory {} -impl<'a, C, NC, A> Directory - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Directory + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Directory { + pub fn new(client: C, authenticator: A) -> Directory { Directory { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn asps(&'a self) -> AspMethods<'a, C, NC, A> { + pub fn asps(&'a self) -> AspMethods<'a, C, A> { AspMethods { hub: &self } } - pub fn channels(&'a self) -> ChannelMethods<'a, C, NC, A> { + pub fn channels(&'a self) -> ChannelMethods<'a, C, A> { ChannelMethods { hub: &self } } - pub fn chromeosdevices(&'a self) -> ChromeosdeviceMethods<'a, C, NC, A> { + pub fn chromeosdevices(&'a self) -> ChromeosdeviceMethods<'a, C, A> { ChromeosdeviceMethods { hub: &self } } - pub fn groups(&'a self) -> GroupMethods<'a, C, NC, A> { + pub fn groups(&'a self) -> GroupMethods<'a, C, A> { GroupMethods { hub: &self } } - pub fn members(&'a self) -> MemberMethods<'a, C, NC, A> { + pub fn members(&'a self) -> MemberMethods<'a, C, A> { MemberMethods { hub: &self } } - pub fn mobiledevices(&'a self) -> MobiledeviceMethods<'a, C, NC, A> { + pub fn mobiledevices(&'a self) -> MobiledeviceMethods<'a, C, A> { MobiledeviceMethods { hub: &self } } - pub fn notifications(&'a self) -> NotificationMethods<'a, C, NC, A> { + pub fn notifications(&'a self) -> NotificationMethods<'a, C, A> { NotificationMethods { hub: &self } } - pub fn orgunits(&'a self) -> OrgunitMethods<'a, C, NC, A> { + pub fn orgunits(&'a self) -> OrgunitMethods<'a, C, A> { OrgunitMethods { hub: &self } } - pub fn schemas(&'a self) -> SchemaMethods<'a, C, NC, A> { + pub fn schemas(&'a self) -> SchemaMethods<'a, C, A> { SchemaMethods { hub: &self } } - pub fn tokens(&'a self) -> TokenMethods<'a, C, NC, A> { + pub fn tokens(&'a self) -> TokenMethods<'a, C, A> { TokenMethods { hub: &self } } - pub fn users(&'a self) -> UserMethods<'a, C, NC, A> { + pub fn users(&'a self) -> UserMethods<'a, C, A> { UserMethods { hub: &self } } - pub fn verification_codes(&'a self) -> VerificationCodeMethods<'a, C, NC, A> { + pub fn verification_codes(&'a self) -> VerificationCodeMethods<'a, C, A> { VerificationCodeMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -1739,15 +1735,15 @@ impl ResponseResult for Aliases {} /// let rb = hub.tokens(); /// # } /// ``` -pub struct TokenMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TokenMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, } -impl<'a, C, NC, A> MethodsBuilder for TokenMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TokenMethods<'a, C, A> {} -impl<'a, C, NC, A> TokenMethods<'a, C, NC, A> { +impl<'a, C, A> TokenMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1757,7 +1753,7 @@ impl<'a, C, NC, A> TokenMethods<'a, C, NC, A> { /// /// * `userKey` - Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID. /// * `clientId` - The Client ID of the application the token is issued to. - pub fn get(&self, user_key: &str, client_id: &str) -> TokenGetCall<'a, C, NC, A> { + pub fn get(&self, user_key: &str, client_id: &str) -> TokenGetCall<'a, C, A> { TokenGetCall { hub: self.hub, _user_key: user_key.to_string(), @@ -1775,7 +1771,7 @@ impl<'a, C, NC, A> TokenMethods<'a, C, NC, A> { /// # Arguments /// /// * `userKey` - Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID. - pub fn list(&self, user_key: &str) -> TokenListCall<'a, C, NC, A> { + pub fn list(&self, user_key: &str) -> TokenListCall<'a, C, A> { TokenListCall { hub: self.hub, _user_key: user_key.to_string(), @@ -1793,7 +1789,7 @@ impl<'a, C, NC, A> TokenMethods<'a, C, NC, A> { /// /// * `userKey` - Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID. /// * `clientId` - The Client ID of the application the token is issued to. - pub fn delete(&self, user_key: &str, client_id: &str) -> TokenDeleteCall<'a, C, NC, A> { + pub fn delete(&self, user_key: &str, client_id: &str) -> TokenDeleteCall<'a, C, A> { TokenDeleteCall { hub: self.hub, _user_key: user_key.to_string(), @@ -1835,15 +1831,15 @@ impl<'a, C, NC, A> TokenMethods<'a, C, NC, A> { /// let rb = hub.channels(); /// # } /// ``` -pub struct ChannelMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChannelMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, } -impl<'a, C, NC, A> MethodsBuilder for ChannelMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ChannelMethods<'a, C, A> {} -impl<'a, C, NC, A> ChannelMethods<'a, C, NC, A> { +impl<'a, C, A> ChannelMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1852,7 +1848,7 @@ impl<'a, C, NC, A> ChannelMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn stop(&self, request: &Channel) -> ChannelStopCall<'a, C, NC, A> { + pub fn stop(&self, request: &Channel) -> ChannelStopCall<'a, C, A> { ChannelStopCall { hub: self.hub, _request: request.clone(), @@ -1893,15 +1889,15 @@ impl<'a, C, NC, A> ChannelMethods<'a, C, NC, A> { /// let rb = hub.orgunits(); /// # } /// ``` -pub struct OrgunitMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct OrgunitMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, } -impl<'a, C, NC, A> MethodsBuilder for OrgunitMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for OrgunitMethods<'a, C, A> {} -impl<'a, C, NC, A> OrgunitMethods<'a, C, NC, A> { +impl<'a, C, A> OrgunitMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1911,7 +1907,7 @@ impl<'a, C, NC, A> OrgunitMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `customerId` - Immutable id of the Google Apps account - pub fn insert(&self, request: &OrgUnit, customer_id: &str) -> OrgunitInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &OrgUnit, customer_id: &str) -> OrgunitInsertCall<'a, C, A> { OrgunitInsertCall { hub: self.hub, _request: request.clone(), @@ -1929,7 +1925,7 @@ impl<'a, C, NC, A> OrgunitMethods<'a, C, NC, A> { /// # Arguments /// /// * `customerId` - Immutable id of the Google Apps account - pub fn list(&self, customer_id: &str) -> OrgunitListCall<'a, C, NC, A> { + pub fn list(&self, customer_id: &str) -> OrgunitListCall<'a, C, A> { OrgunitListCall { hub: self.hub, _customer_id: customer_id.to_string(), @@ -1949,7 +1945,7 @@ impl<'a, C, NC, A> OrgunitMethods<'a, C, NC, A> { /// /// * `customerId` - Immutable id of the Google Apps account /// * `orgUnitPath` - Full path of the organization unit or its Id - pub fn get(&self, customer_id: &str, org_unit_path: &Vec) -> OrgunitGetCall<'a, C, NC, A> { + pub fn get(&self, customer_id: &str, org_unit_path: &Vec) -> OrgunitGetCall<'a, C, A> { OrgunitGetCall { hub: self.hub, _customer_id: customer_id.to_string(), @@ -1969,7 +1965,7 @@ impl<'a, C, NC, A> OrgunitMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `customerId` - Immutable id of the Google Apps account /// * `orgUnitPath` - Full path of the organization unit or its Id - pub fn update(&self, request: &OrgUnit, customer_id: &str, org_unit_path: &Vec) -> OrgunitUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &OrgUnit, customer_id: &str, org_unit_path: &Vec) -> OrgunitUpdateCall<'a, C, A> { OrgunitUpdateCall { hub: self.hub, _request: request.clone(), @@ -1989,7 +1985,7 @@ impl<'a, C, NC, A> OrgunitMethods<'a, C, NC, A> { /// /// * `customerId` - Immutable id of the Google Apps account /// * `orgUnitPath` - Full path of the organization unit or its Id - pub fn delete(&self, customer_id: &str, org_unit_path: &Vec) -> OrgunitDeleteCall<'a, C, NC, A> { + pub fn delete(&self, customer_id: &str, org_unit_path: &Vec) -> OrgunitDeleteCall<'a, C, A> { OrgunitDeleteCall { hub: self.hub, _customer_id: customer_id.to_string(), @@ -2009,7 +2005,7 @@ impl<'a, C, NC, A> OrgunitMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `customerId` - Immutable id of the Google Apps account /// * `orgUnitPath` - Full path of the organization unit or its Id - pub fn patch(&self, request: &OrgUnit, customer_id: &str, org_unit_path: &Vec) -> OrgunitPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &OrgUnit, customer_id: &str, org_unit_path: &Vec) -> OrgunitPatchCall<'a, C, A> { OrgunitPatchCall { hub: self.hub, _request: request.clone(), @@ -2052,15 +2048,15 @@ impl<'a, C, NC, A> OrgunitMethods<'a, C, NC, A> { /// let rb = hub.users(); /// # } /// ``` -pub struct UserMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, } -impl<'a, C, NC, A> MethodsBuilder for UserMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for UserMethods<'a, C, A> {} -impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { +impl<'a, C, A> UserMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2069,7 +2065,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &User) -> UserInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &User) -> UserInsertCall<'a, C, A> { UserInsertCall { hub: self.hub, _request: request.clone(), @@ -2086,7 +2082,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// # Arguments /// /// * `userKey` - Email or immutable Id of the user - pub fn photos_delete(&self, user_key: &str) -> UserPhotoDeleteCall<'a, C, NC, A> { + pub fn photos_delete(&self, user_key: &str) -> UserPhotoDeleteCall<'a, C, A> { UserPhotoDeleteCall { hub: self.hub, _user_key: user_key.to_string(), @@ -2104,7 +2100,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `userKey` - The immutable id of the user - pub fn undelete(&self, request: &UserUndelete, user_key: &str) -> UserUndeleteCall<'a, C, NC, A> { + pub fn undelete(&self, request: &UserUndelete, user_key: &str) -> UserUndeleteCall<'a, C, A> { UserUndeleteCall { hub: self.hub, _request: request.clone(), @@ -2123,7 +2119,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `userKey` - Email or immutable Id of the user as admin - pub fn make_admin(&self, request: &UserMakeAdmin, user_key: &str) -> UserMakeAdminCall<'a, C, NC, A> { + pub fn make_admin(&self, request: &UserMakeAdmin, user_key: &str) -> UserMakeAdminCall<'a, C, A> { UserMakeAdminCall { hub: self.hub, _request: request.clone(), @@ -2142,7 +2138,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `userKey` - Email or immutable Id of the user. If Id, it should match with id of user object - pub fn patch(&self, request: &User, user_key: &str) -> UserPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &User, user_key: &str) -> UserPatchCall<'a, C, A> { UserPatchCall { hub: self.hub, _request: request.clone(), @@ -2160,7 +2156,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn watch(&self, request: &Channel) -> UserWatchCall<'a, C, NC, A> { + pub fn watch(&self, request: &Channel) -> UserWatchCall<'a, C, A> { UserWatchCall { hub: self.hub, _request: request.clone(), @@ -2189,7 +2185,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// # Arguments /// /// * `userKey` - Email or immutable Id of the user - pub fn delete(&self, user_key: &str) -> UserDeleteCall<'a, C, NC, A> { + pub fn delete(&self, user_key: &str) -> UserDeleteCall<'a, C, A> { UserDeleteCall { hub: self.hub, _user_key: user_key.to_string(), @@ -2207,7 +2203,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `userKey` - Email or immutable Id of the user - pub fn photos_update(&self, request: &UserPhoto, user_key: &str) -> UserPhotoUpdateCall<'a, C, NC, A> { + pub fn photos_update(&self, request: &UserPhoto, user_key: &str) -> UserPhotoUpdateCall<'a, C, A> { UserPhotoUpdateCall { hub: self.hub, _request: request.clone(), @@ -2225,7 +2221,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// # Arguments /// /// * `userKey` - Email or immutable Id of the user - pub fn get(&self, user_key: &str) -> UserGetCall<'a, C, NC, A> { + pub fn get(&self, user_key: &str) -> UserGetCall<'a, C, A> { UserGetCall { hub: self.hub, _user_key: user_key.to_string(), @@ -2246,7 +2242,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `userKey` - Email or immutable Id of the user - pub fn aliases_insert(&self, request: &Alias, user_key: &str) -> UserAliaseInsertCall<'a, C, NC, A> { + pub fn aliases_insert(&self, request: &Alias, user_key: &str) -> UserAliaseInsertCall<'a, C, A> { UserAliaseInsertCall { hub: self.hub, _request: request.clone(), @@ -2260,7 +2256,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Retrieve either deleted users or all users in a domain (paginated) - pub fn list(&self) -> UserListCall<'a, C, NC, A> { + pub fn list(&self) -> UserListCall<'a, C, A> { UserListCall { hub: self.hub, _view_type: Default::default(), @@ -2289,7 +2285,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `userKey` - Email or immutable Id of the user /// * `alias` - The alias to be removed - pub fn aliases_delete(&self, user_key: &str, alias: &str) -> UserAliaseDeleteCall<'a, C, NC, A> { + pub fn aliases_delete(&self, user_key: &str, alias: &str) -> UserAliaseDeleteCall<'a, C, A> { UserAliaseDeleteCall { hub: self.hub, _user_key: user_key.to_string(), @@ -2308,7 +2304,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `userKey` - Email or immutable Id of the user. If Id, it should match with id of user object - pub fn update(&self, request: &User, user_key: &str) -> UserUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &User, user_key: &str) -> UserUpdateCall<'a, C, A> { UserUpdateCall { hub: self.hub, _request: request.clone(), @@ -2327,7 +2323,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `userKey` - Email or immutable Id of the user - pub fn aliases_watch(&self, request: &Channel, user_key: &str) -> UserAliaseWatchCall<'a, C, NC, A> { + pub fn aliases_watch(&self, request: &Channel, user_key: &str) -> UserAliaseWatchCall<'a, C, A> { UserAliaseWatchCall { hub: self.hub, _request: request.clone(), @@ -2346,7 +2342,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// # Arguments /// /// * `userKey` - Email or immutable Id of the user - pub fn aliases_list(&self, user_key: &str) -> UserAliaseListCall<'a, C, NC, A> { + pub fn aliases_list(&self, user_key: &str) -> UserAliaseListCall<'a, C, A> { UserAliaseListCall { hub: self.hub, _user_key: user_key.to_string(), @@ -2364,7 +2360,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// # Arguments /// /// * `userKey` - Email or immutable Id of the user - pub fn photos_get(&self, user_key: &str) -> UserPhotoGetCall<'a, C, NC, A> { + pub fn photos_get(&self, user_key: &str) -> UserPhotoGetCall<'a, C, A> { UserPhotoGetCall { hub: self.hub, _user_key: user_key.to_string(), @@ -2382,7 +2378,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `userKey` - Email or immutable Id of the user - pub fn photos_patch(&self, request: &UserPhoto, user_key: &str) -> UserPhotoPatchCall<'a, C, NC, A> { + pub fn photos_patch(&self, request: &UserPhoto, user_key: &str) -> UserPhotoPatchCall<'a, C, A> { UserPhotoPatchCall { hub: self.hub, _request: request.clone(), @@ -2424,15 +2420,15 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// let rb = hub.mobiledevices(); /// # } /// ``` -pub struct MobiledeviceMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MobiledeviceMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, } -impl<'a, C, NC, A> MethodsBuilder for MobiledeviceMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for MobiledeviceMethods<'a, C, A> {} -impl<'a, C, NC, A> MobiledeviceMethods<'a, C, NC, A> { +impl<'a, C, A> MobiledeviceMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2442,7 +2438,7 @@ impl<'a, C, NC, A> MobiledeviceMethods<'a, C, NC, A> { /// /// * `customerId` - Immutable id of the Google Apps account /// * `resourceId` - Immutable id of Mobile Device - pub fn delete(&self, customer_id: &str, resource_id: &str) -> MobiledeviceDeleteCall<'a, C, NC, A> { + pub fn delete(&self, customer_id: &str, resource_id: &str) -> MobiledeviceDeleteCall<'a, C, A> { MobiledeviceDeleteCall { hub: self.hub, _customer_id: customer_id.to_string(), @@ -2461,7 +2457,7 @@ impl<'a, C, NC, A> MobiledeviceMethods<'a, C, NC, A> { /// /// * `customerId` - Immutable id of the Google Apps account /// * `resourceId` - Immutable id of Mobile Device - pub fn get(&self, customer_id: &str, resource_id: &str) -> MobiledeviceGetCall<'a, C, NC, A> { + pub fn get(&self, customer_id: &str, resource_id: &str) -> MobiledeviceGetCall<'a, C, A> { MobiledeviceGetCall { hub: self.hub, _customer_id: customer_id.to_string(), @@ -2480,7 +2476,7 @@ impl<'a, C, NC, A> MobiledeviceMethods<'a, C, NC, A> { /// # Arguments /// /// * `customerId` - Immutable id of the Google Apps account - pub fn list(&self, customer_id: &str) -> MobiledeviceListCall<'a, C, NC, A> { + pub fn list(&self, customer_id: &str) -> MobiledeviceListCall<'a, C, A> { MobiledeviceListCall { hub: self.hub, _customer_id: customer_id.to_string(), @@ -2505,7 +2501,7 @@ impl<'a, C, NC, A> MobiledeviceMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `customerId` - Immutable id of the Google Apps account /// * `resourceId` - Immutable id of Mobile Device - pub fn action(&self, request: &MobileDeviceAction, customer_id: &str, resource_id: &str) -> MobiledeviceActionCall<'a, C, NC, A> { + pub fn action(&self, request: &MobileDeviceAction, customer_id: &str, resource_id: &str) -> MobiledeviceActionCall<'a, C, A> { MobiledeviceActionCall { hub: self.hub, _request: request.clone(), @@ -2548,15 +2544,15 @@ impl<'a, C, NC, A> MobiledeviceMethods<'a, C, NC, A> { /// let rb = hub.members(); /// # } /// ``` -pub struct MemberMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MemberMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, } -impl<'a, C, NC, A> MethodsBuilder for MemberMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for MemberMethods<'a, C, A> {} -impl<'a, C, NC, A> MemberMethods<'a, C, NC, A> { +impl<'a, C, A> MemberMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2567,7 +2563,7 @@ impl<'a, C, NC, A> MemberMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `groupKey` - Email or immutable Id of the group. If Id, it should match with id of group object /// * `memberKey` - Email or immutable Id of the user. If Id, it should match with id of member object - pub fn update(&self, request: &Member, group_key: &str, member_key: &str) -> MemberUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Member, group_key: &str, member_key: &str) -> MemberUpdateCall<'a, C, A> { MemberUpdateCall { hub: self.hub, _request: request.clone(), @@ -2587,7 +2583,7 @@ impl<'a, C, NC, A> MemberMethods<'a, C, NC, A> { /// /// * `groupKey` - Email or immutable Id of the group /// * `memberKey` - Email or immutable Id of the member - pub fn get(&self, group_key: &str, member_key: &str) -> MemberGetCall<'a, C, NC, A> { + pub fn get(&self, group_key: &str, member_key: &str) -> MemberGetCall<'a, C, A> { MemberGetCall { hub: self.hub, _group_key: group_key.to_string(), @@ -2606,7 +2602,7 @@ impl<'a, C, NC, A> MemberMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `groupKey` - Email or immutable Id of the group - pub fn insert(&self, request: &Member, group_key: &str) -> MemberInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Member, group_key: &str) -> MemberInsertCall<'a, C, A> { MemberInsertCall { hub: self.hub, _request: request.clone(), @@ -2626,7 +2622,7 @@ impl<'a, C, NC, A> MemberMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `groupKey` - Email or immutable Id of the group. If Id, it should match with id of group object /// * `memberKey` - Email or immutable Id of the user. If Id, it should match with id of member object - pub fn patch(&self, request: &Member, group_key: &str, member_key: &str) -> MemberPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Member, group_key: &str, member_key: &str) -> MemberPatchCall<'a, C, A> { MemberPatchCall { hub: self.hub, _request: request.clone(), @@ -2646,7 +2642,7 @@ impl<'a, C, NC, A> MemberMethods<'a, C, NC, A> { /// /// * `groupKey` - Email or immutable Id of the group /// * `memberKey` - Email or immutable Id of the member - pub fn delete(&self, group_key: &str, member_key: &str) -> MemberDeleteCall<'a, C, NC, A> { + pub fn delete(&self, group_key: &str, member_key: &str) -> MemberDeleteCall<'a, C, A> { MemberDeleteCall { hub: self.hub, _group_key: group_key.to_string(), @@ -2664,7 +2660,7 @@ impl<'a, C, NC, A> MemberMethods<'a, C, NC, A> { /// # Arguments /// /// * `groupKey` - Email or immutable Id of the group - pub fn list(&self, group_key: &str) -> MemberListCall<'a, C, NC, A> { + pub fn list(&self, group_key: &str) -> MemberListCall<'a, C, A> { MemberListCall { hub: self.hub, _group_key: group_key.to_string(), @@ -2708,15 +2704,15 @@ impl<'a, C, NC, A> MemberMethods<'a, C, NC, A> { /// let rb = hub.notifications(); /// # } /// ``` -pub struct NotificationMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct NotificationMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, } -impl<'a, C, NC, A> MethodsBuilder for NotificationMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for NotificationMethods<'a, C, A> {} -impl<'a, C, NC, A> NotificationMethods<'a, C, NC, A> { +impl<'a, C, A> NotificationMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2725,7 +2721,7 @@ impl<'a, C, NC, A> NotificationMethods<'a, C, NC, A> { /// # Arguments /// /// * `customer` - The unique ID for the customer's Google account. - pub fn list(&self, customer: &str) -> NotificationListCall<'a, C, NC, A> { + pub fn list(&self, customer: &str) -> NotificationListCall<'a, C, A> { NotificationListCall { hub: self.hub, _customer: customer.to_string(), @@ -2746,7 +2742,7 @@ impl<'a, C, NC, A> NotificationMethods<'a, C, NC, A> { /// /// * `customer` - The unique ID for the customer's Google account. The customerId is also returned as part of the Users resource. /// * `notificationId` - The unique ID of the notification. - pub fn delete(&self, customer: &str, notification_id: &str) -> NotificationDeleteCall<'a, C, NC, A> { + pub fn delete(&self, customer: &str, notification_id: &str) -> NotificationDeleteCall<'a, C, A> { NotificationDeleteCall { hub: self.hub, _customer: customer.to_string(), @@ -2766,7 +2762,7 @@ impl<'a, C, NC, A> NotificationMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `customer` - The unique ID for the customer's Google account. /// * `notificationId` - The unique ID of the notification. - pub fn patch(&self, request: &Notification, customer: &str, notification_id: &str) -> NotificationPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Notification, customer: &str, notification_id: &str) -> NotificationPatchCall<'a, C, A> { NotificationPatchCall { hub: self.hub, _request: request.clone(), @@ -2787,7 +2783,7 @@ impl<'a, C, NC, A> NotificationMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `customer` - The unique ID for the customer's Google account. /// * `notificationId` - The unique ID of the notification. - pub fn update(&self, request: &Notification, customer: &str, notification_id: &str) -> NotificationUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Notification, customer: &str, notification_id: &str) -> NotificationUpdateCall<'a, C, A> { NotificationUpdateCall { hub: self.hub, _request: request.clone(), @@ -2807,7 +2803,7 @@ impl<'a, C, NC, A> NotificationMethods<'a, C, NC, A> { /// /// * `customer` - The unique ID for the customer's Google account. The customerId is also returned as part of the Users resource. /// * `notificationId` - The unique ID of the notification. - pub fn get(&self, customer: &str, notification_id: &str) -> NotificationGetCall<'a, C, NC, A> { + pub fn get(&self, customer: &str, notification_id: &str) -> NotificationGetCall<'a, C, A> { NotificationGetCall { hub: self.hub, _customer: customer.to_string(), @@ -2849,15 +2845,15 @@ impl<'a, C, NC, A> NotificationMethods<'a, C, NC, A> { /// let rb = hub.chromeosdevices(); /// # } /// ``` -pub struct ChromeosdeviceMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChromeosdeviceMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, } -impl<'a, C, NC, A> MethodsBuilder for ChromeosdeviceMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ChromeosdeviceMethods<'a, C, A> {} -impl<'a, C, NC, A> ChromeosdeviceMethods<'a, C, NC, A> { +impl<'a, C, A> ChromeosdeviceMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2866,7 +2862,7 @@ impl<'a, C, NC, A> ChromeosdeviceMethods<'a, C, NC, A> { /// # Arguments /// /// * `customerId` - Immutable id of the Google Apps account - pub fn list(&self, customer_id: &str) -> ChromeosdeviceListCall<'a, C, NC, A> { + pub fn list(&self, customer_id: &str) -> ChromeosdeviceListCall<'a, C, A> { ChromeosdeviceListCall { hub: self.hub, _customer_id: customer_id.to_string(), @@ -2891,7 +2887,7 @@ impl<'a, C, NC, A> ChromeosdeviceMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `customerId` - Immutable id of the Google Apps account /// * `deviceId` - Immutable id of Chrome OS Device - pub fn patch(&self, request: &ChromeOsDevice, customer_id: &str, device_id: &str) -> ChromeosdevicePatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &ChromeOsDevice, customer_id: &str, device_id: &str) -> ChromeosdevicePatchCall<'a, C, A> { ChromeosdevicePatchCall { hub: self.hub, _request: request.clone(), @@ -2912,7 +2908,7 @@ impl<'a, C, NC, A> ChromeosdeviceMethods<'a, C, NC, A> { /// /// * `customerId` - Immutable id of the Google Apps account /// * `deviceId` - Immutable id of Chrome OS Device - pub fn get(&self, customer_id: &str, device_id: &str) -> ChromeosdeviceGetCall<'a, C, NC, A> { + pub fn get(&self, customer_id: &str, device_id: &str) -> ChromeosdeviceGetCall<'a, C, A> { ChromeosdeviceGetCall { hub: self.hub, _customer_id: customer_id.to_string(), @@ -2933,7 +2929,7 @@ impl<'a, C, NC, A> ChromeosdeviceMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `customerId` - Immutable id of the Google Apps account /// * `deviceId` - Immutable id of Chrome OS Device - pub fn update(&self, request: &ChromeOsDevice, customer_id: &str, device_id: &str) -> ChromeosdeviceUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &ChromeOsDevice, customer_id: &str, device_id: &str) -> ChromeosdeviceUpdateCall<'a, C, A> { ChromeosdeviceUpdateCall { hub: self.hub, _request: request.clone(), @@ -2977,15 +2973,15 @@ impl<'a, C, NC, A> ChromeosdeviceMethods<'a, C, NC, A> { /// let rb = hub.verification_codes(); /// # } /// ``` -pub struct VerificationCodeMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VerificationCodeMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, } -impl<'a, C, NC, A> MethodsBuilder for VerificationCodeMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for VerificationCodeMethods<'a, C, A> {} -impl<'a, C, NC, A> VerificationCodeMethods<'a, C, NC, A> { +impl<'a, C, A> VerificationCodeMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2994,7 +2990,7 @@ impl<'a, C, NC, A> VerificationCodeMethods<'a, C, NC, A> { /// # Arguments /// /// * `userKey` - Email or immutable Id of the user - pub fn generate(&self, user_key: &str) -> VerificationCodeGenerateCall<'a, C, NC, A> { + pub fn generate(&self, user_key: &str) -> VerificationCodeGenerateCall<'a, C, A> { VerificationCodeGenerateCall { hub: self.hub, _user_key: user_key.to_string(), @@ -3011,7 +3007,7 @@ impl<'a, C, NC, A> VerificationCodeMethods<'a, C, NC, A> { /// # Arguments /// /// * `userKey` - Email or immutable Id of the user - pub fn invalidate(&self, user_key: &str) -> VerificationCodeInvalidateCall<'a, C, NC, A> { + pub fn invalidate(&self, user_key: &str) -> VerificationCodeInvalidateCall<'a, C, A> { VerificationCodeInvalidateCall { hub: self.hub, _user_key: user_key.to_string(), @@ -3028,7 +3024,7 @@ impl<'a, C, NC, A> VerificationCodeMethods<'a, C, NC, A> { /// # Arguments /// /// * `userKey` - Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID. - pub fn list(&self, user_key: &str) -> VerificationCodeListCall<'a, C, NC, A> { + pub fn list(&self, user_key: &str) -> VerificationCodeListCall<'a, C, A> { VerificationCodeListCall { hub: self.hub, _user_key: user_key.to_string(), @@ -3069,15 +3065,15 @@ impl<'a, C, NC, A> VerificationCodeMethods<'a, C, NC, A> { /// let rb = hub.groups(); /// # } /// ``` -pub struct GroupMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GroupMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, } -impl<'a, C, NC, A> MethodsBuilder for GroupMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for GroupMethods<'a, C, A> {} -impl<'a, C, NC, A> GroupMethods<'a, C, NC, A> { +impl<'a, C, A> GroupMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3086,7 +3082,7 @@ impl<'a, C, NC, A> GroupMethods<'a, C, NC, A> { /// # Arguments /// /// * `groupKey` - Email or immutable Id of the group - pub fn get(&self, group_key: &str) -> GroupGetCall<'a, C, NC, A> { + pub fn get(&self, group_key: &str) -> GroupGetCall<'a, C, A> { GroupGetCall { hub: self.hub, _group_key: group_key.to_string(), @@ -3099,7 +3095,7 @@ impl<'a, C, NC, A> GroupMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Retrieve all groups in a domain (paginated) - pub fn list(&self) -> GroupListCall<'a, C, NC, A> { + pub fn list(&self) -> GroupListCall<'a, C, A> { GroupListCall { hub: self.hub, _user_key: Default::default(), @@ -3120,7 +3116,7 @@ impl<'a, C, NC, A> GroupMethods<'a, C, NC, A> { /// # Arguments /// /// * `groupKey` - Email or immutable Id of the group - pub fn aliases_list(&self, group_key: &str) -> GroupAliaseListCall<'a, C, NC, A> { + pub fn aliases_list(&self, group_key: &str) -> GroupAliaseListCall<'a, C, A> { GroupAliaseListCall { hub: self.hub, _group_key: group_key.to_string(), @@ -3138,7 +3134,7 @@ impl<'a, C, NC, A> GroupMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `groupKey` - Email or immutable Id of the group. If Id, it should match with id of group object - pub fn patch(&self, request: &Group, group_key: &str) -> GroupPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Group, group_key: &str) -> GroupPatchCall<'a, C, A> { GroupPatchCall { hub: self.hub, _request: request.clone(), @@ -3157,7 +3153,7 @@ impl<'a, C, NC, A> GroupMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `groupKey` - Email or immutable Id of the group. If Id, it should match with id of group object - pub fn update(&self, request: &Group, group_key: &str) -> GroupUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Group, group_key: &str) -> GroupUpdateCall<'a, C, A> { GroupUpdateCall { hub: self.hub, _request: request.clone(), @@ -3175,7 +3171,7 @@ impl<'a, C, NC, A> GroupMethods<'a, C, NC, A> { /// # Arguments /// /// * `groupKey` - Email or immutable Id of the group - pub fn delete(&self, group_key: &str) -> GroupDeleteCall<'a, C, NC, A> { + pub fn delete(&self, group_key: &str) -> GroupDeleteCall<'a, C, A> { GroupDeleteCall { hub: self.hub, _group_key: group_key.to_string(), @@ -3193,7 +3189,7 @@ impl<'a, C, NC, A> GroupMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `groupKey` - Email or immutable Id of the group - pub fn aliases_insert(&self, request: &Alias, group_key: &str) -> GroupAliaseInsertCall<'a, C, NC, A> { + pub fn aliases_insert(&self, request: &Alias, group_key: &str) -> GroupAliaseInsertCall<'a, C, A> { GroupAliaseInsertCall { hub: self.hub, _request: request.clone(), @@ -3212,7 +3208,7 @@ impl<'a, C, NC, A> GroupMethods<'a, C, NC, A> { /// /// * `groupKey` - Email or immutable Id of the group /// * `alias` - The alias to be removed - pub fn aliases_delete(&self, group_key: &str, alias: &str) -> GroupAliaseDeleteCall<'a, C, NC, A> { + pub fn aliases_delete(&self, group_key: &str, alias: &str) -> GroupAliaseDeleteCall<'a, C, A> { GroupAliaseDeleteCall { hub: self.hub, _group_key: group_key.to_string(), @@ -3230,7 +3226,7 @@ impl<'a, C, NC, A> GroupMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &Group) -> GroupInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Group) -> GroupInsertCall<'a, C, A> { GroupInsertCall { hub: self.hub, _request: request.clone(), @@ -3271,15 +3267,15 @@ impl<'a, C, NC, A> GroupMethods<'a, C, NC, A> { /// let rb = hub.asps(); /// # } /// ``` -pub struct AspMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AspMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, } -impl<'a, C, NC, A> MethodsBuilder for AspMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AspMethods<'a, C, A> {} -impl<'a, C, NC, A> AspMethods<'a, C, NC, A> { +impl<'a, C, A> AspMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3289,7 +3285,7 @@ impl<'a, C, NC, A> AspMethods<'a, C, NC, A> { /// /// * `userKey` - Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID. /// * `codeId` - The unique ID of the ASP to be deleted. - pub fn delete(&self, user_key: &str, code_id: i32) -> AspDeleteCall<'a, C, NC, A> { + pub fn delete(&self, user_key: &str, code_id: i32) -> AspDeleteCall<'a, C, A> { AspDeleteCall { hub: self.hub, _user_key: user_key.to_string(), @@ -3307,7 +3303,7 @@ impl<'a, C, NC, A> AspMethods<'a, C, NC, A> { /// # Arguments /// /// * `userKey` - Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID. - pub fn list(&self, user_key: &str) -> AspListCall<'a, C, NC, A> { + pub fn list(&self, user_key: &str) -> AspListCall<'a, C, A> { AspListCall { hub: self.hub, _user_key: user_key.to_string(), @@ -3325,7 +3321,7 @@ impl<'a, C, NC, A> AspMethods<'a, C, NC, A> { /// /// * `userKey` - Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID. /// * `codeId` - The unique ID of the ASP. - pub fn get(&self, user_key: &str, code_id: i32) -> AspGetCall<'a, C, NC, A> { + pub fn get(&self, user_key: &str, code_id: i32) -> AspGetCall<'a, C, A> { AspGetCall { hub: self.hub, _user_key: user_key.to_string(), @@ -3367,15 +3363,15 @@ impl<'a, C, NC, A> AspMethods<'a, C, NC, A> { /// let rb = hub.schemas(); /// # } /// ``` -pub struct SchemaMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SchemaMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, } -impl<'a, C, NC, A> MethodsBuilder for SchemaMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for SchemaMethods<'a, C, A> {} -impl<'a, C, NC, A> SchemaMethods<'a, C, NC, A> { +impl<'a, C, A> SchemaMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3384,7 +3380,7 @@ impl<'a, C, NC, A> SchemaMethods<'a, C, NC, A> { /// # Arguments /// /// * `customerId` - Immutable id of the Google Apps account - pub fn list(&self, customer_id: &str) -> SchemaListCall<'a, C, NC, A> { + pub fn list(&self, customer_id: &str) -> SchemaListCall<'a, C, A> { SchemaListCall { hub: self.hub, _customer_id: customer_id.to_string(), @@ -3402,7 +3398,7 @@ impl<'a, C, NC, A> SchemaMethods<'a, C, NC, A> { /// /// * `customerId` - Immutable id of the Google Apps account /// * `schemaKey` - Name or immutable Id of the schema - pub fn get(&self, customer_id: &str, schema_key: &str) -> SchemaGetCall<'a, C, NC, A> { + pub fn get(&self, customer_id: &str, schema_key: &str) -> SchemaGetCall<'a, C, A> { SchemaGetCall { hub: self.hub, _customer_id: customer_id.to_string(), @@ -3422,7 +3418,7 @@ impl<'a, C, NC, A> SchemaMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `customerId` - Immutable id of the Google Apps account /// * `schemaKey` - Name or immutable Id of the schema. - pub fn patch(&self, request: &Schema, customer_id: &str, schema_key: &str) -> SchemaPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Schema, customer_id: &str, schema_key: &str) -> SchemaPatchCall<'a, C, A> { SchemaPatchCall { hub: self.hub, _request: request.clone(), @@ -3442,7 +3438,7 @@ impl<'a, C, NC, A> SchemaMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `customerId` - Immutable id of the Google Apps account - pub fn insert(&self, request: &Schema, customer_id: &str) -> SchemaInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Schema, customer_id: &str) -> SchemaInsertCall<'a, C, A> { SchemaInsertCall { hub: self.hub, _request: request.clone(), @@ -3461,7 +3457,7 @@ impl<'a, C, NC, A> SchemaMethods<'a, C, NC, A> { /// /// * `customerId` - Immutable id of the Google Apps account /// * `schemaKey` - Name or immutable Id of the schema - pub fn delete(&self, customer_id: &str, schema_key: &str) -> SchemaDeleteCall<'a, C, NC, A> { + pub fn delete(&self, customer_id: &str, schema_key: &str) -> SchemaDeleteCall<'a, C, A> { SchemaDeleteCall { hub: self.hub, _customer_id: customer_id.to_string(), @@ -3481,7 +3477,7 @@ impl<'a, C, NC, A> SchemaMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `customerId` - Immutable id of the Google Apps account /// * `schemaKey` - Name or immutable Id of the schema. - pub fn update(&self, request: &Schema, customer_id: &str, schema_key: &str) -> SchemaUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Schema, customer_id: &str, schema_key: &str) -> SchemaUpdateCall<'a, C, A> { SchemaUpdateCall { hub: self.hub, _request: request.clone(), @@ -3532,10 +3528,10 @@ impl<'a, C, NC, A> SchemaMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct TokenGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TokenGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _user_key: String, _client_id: String, _delegate: Option<&'a mut Delegate>, @@ -3543,9 +3539,9 @@ pub struct TokenGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TokenGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TokenGetCall<'a, C, A> {} -impl<'a, C, NC, A> TokenGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TokenGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3678,7 +3674,7 @@ impl<'a, C, NC, A> TokenGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID. - pub fn user_key(mut self, new_value: &str) -> TokenGetCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> TokenGetCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -3688,7 +3684,7 @@ impl<'a, C, NC, A> TokenGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The Client ID of the application the token is issued to. - pub fn client_id(mut self, new_value: &str) -> TokenGetCall<'a, C, NC, A> { + pub fn client_id(mut self, new_value: &str) -> TokenGetCall<'a, C, A> { self._client_id = new_value.to_string(); self } @@ -3699,7 +3695,7 @@ impl<'a, C, NC, A> TokenGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TokenGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TokenGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3720,7 +3716,7 @@ impl<'a, C, NC, A> TokenGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TokenGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TokenGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3737,7 +3733,7 @@ impl<'a, C, NC, A> TokenGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TokenGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TokenGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3775,19 +3771,19 @@ impl<'a, C, NC, A> TokenGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct TokenListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TokenListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _user_key: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TokenListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TokenListCall<'a, C, A> {} -impl<'a, C, NC, A> TokenListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TokenListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3919,7 +3915,7 @@ impl<'a, C, NC, A> TokenListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID. - pub fn user_key(mut self, new_value: &str) -> TokenListCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> TokenListCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -3930,7 +3926,7 @@ impl<'a, C, NC, A> TokenListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TokenListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TokenListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3951,7 +3947,7 @@ impl<'a, C, NC, A> TokenListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TokenListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TokenListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3968,7 +3964,7 @@ impl<'a, C, NC, A> TokenListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TokenListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TokenListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4006,10 +4002,10 @@ impl<'a, C, NC, A> TokenListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct TokenDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TokenDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _user_key: String, _client_id: String, _delegate: Option<&'a mut Delegate>, @@ -4017,9 +4013,9 @@ pub struct TokenDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TokenDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TokenDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> TokenDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TokenDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4141,7 +4137,7 @@ impl<'a, C, NC, A> TokenDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID. - pub fn user_key(mut self, new_value: &str) -> TokenDeleteCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> TokenDeleteCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -4151,7 +4147,7 @@ impl<'a, C, NC, A> TokenDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The Client ID of the application the token is issued to. - pub fn client_id(mut self, new_value: &str) -> TokenDeleteCall<'a, C, NC, A> { + pub fn client_id(mut self, new_value: &str) -> TokenDeleteCall<'a, C, A> { self._client_id = new_value.to_string(); self } @@ -4162,7 +4158,7 @@ impl<'a, C, NC, A> TokenDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TokenDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TokenDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4183,7 +4179,7 @@ impl<'a, C, NC, A> TokenDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TokenDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TokenDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4200,7 +4196,7 @@ impl<'a, C, NC, A> TokenDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TokenDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TokenDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4244,19 +4240,19 @@ impl<'a, C, NC, A> TokenDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct ChannelStopCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChannelStopCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: Channel, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChannelStopCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChannelStopCall<'a, C, A> {} -impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChannelStopCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4359,7 +4355,7 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Channel) -> ChannelStopCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Channel) -> ChannelStopCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4370,7 +4366,7 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelStopCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelStopCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4391,7 +4387,7 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChannelStopCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChannelStopCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4408,7 +4404,7 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChannelStopCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChannelStopCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4452,10 +4448,10 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct OrgunitInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct OrgunitInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: OrgUnit, _customer_id: String, _delegate: Option<&'a mut Delegate>, @@ -4463,9 +4459,9 @@ pub struct OrgunitInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for OrgunitInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for OrgunitInsertCall<'a, C, A> {} -impl<'a, C, NC, A> OrgunitInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> OrgunitInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4604,7 +4600,7 @@ impl<'a, C, NC, A> OrgunitInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &OrgUnit) -> OrgunitInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &OrgUnit) -> OrgunitInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4614,7 +4610,7 @@ impl<'a, C, NC, A> OrgunitInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Immutable id of the Google Apps account - pub fn customer_id(mut self, new_value: &str) -> OrgunitInsertCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> OrgunitInsertCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -4625,7 +4621,7 @@ impl<'a, C, NC, A> OrgunitInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> OrgunitInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> OrgunitInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4646,7 +4642,7 @@ impl<'a, C, NC, A> OrgunitInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> OrgunitInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> OrgunitInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4663,7 +4659,7 @@ impl<'a, C, NC, A> OrgunitInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> OrgunitInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> OrgunitInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4703,10 +4699,10 @@ impl<'a, C, NC, A> OrgunitInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct OrgunitListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct OrgunitListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _customer_id: String, _type_: Option, _org_unit_path: Option, @@ -4715,9 +4711,9 @@ pub struct OrgunitListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for OrgunitListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for OrgunitListCall<'a, C, A> {} -impl<'a, C, NC, A> OrgunitListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> OrgunitListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4855,7 +4851,7 @@ impl<'a, C, NC, A> OrgunitListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Immutable id of the Google Apps account - pub fn customer_id(mut self, new_value: &str) -> OrgunitListCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> OrgunitListCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -4863,7 +4859,7 @@ impl<'a, C, NC, A> OrgunitListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Whether to return all sub-organizations or just immediate children - pub fn type_(mut self, new_value: &str) -> OrgunitListCall<'a, C, NC, A> { + pub fn type_(mut self, new_value: &str) -> OrgunitListCall<'a, C, A> { self._type_ = Some(new_value.to_string()); self } @@ -4871,7 +4867,7 @@ impl<'a, C, NC, A> OrgunitListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// the URL-encoded organization unit's path or its Id - pub fn org_unit_path(mut self, new_value: &str) -> OrgunitListCall<'a, C, NC, A> { + pub fn org_unit_path(mut self, new_value: &str) -> OrgunitListCall<'a, C, A> { self._org_unit_path = Some(new_value.to_string()); self } @@ -4882,7 +4878,7 @@ impl<'a, C, NC, A> OrgunitListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> OrgunitListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> OrgunitListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4903,7 +4899,7 @@ impl<'a, C, NC, A> OrgunitListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> OrgunitListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> OrgunitListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4920,7 +4916,7 @@ impl<'a, C, NC, A> OrgunitListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> OrgunitListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> OrgunitListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4958,10 +4954,10 @@ impl<'a, C, NC, A> OrgunitListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct OrgunitGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct OrgunitGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _customer_id: String, _org_unit_path: Vec, _delegate: Option<&'a mut Delegate>, @@ -4969,9 +4965,9 @@ pub struct OrgunitGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for OrgunitGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for OrgunitGetCall<'a, C, A> {} -impl<'a, C, NC, A> OrgunitGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> OrgunitGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5110,7 +5106,7 @@ impl<'a, C, NC, A> OrgunitGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Immutable id of the Google Apps account - pub fn customer_id(mut self, new_value: &str) -> OrgunitGetCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> OrgunitGetCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -5121,7 +5117,7 @@ impl<'a, C, NC, A> OrgunitGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Full path of the organization unit or its Id - pub fn add_org_unit_path(mut self, new_value: &str) -> OrgunitGetCall<'a, C, NC, A> { + pub fn add_org_unit_path(mut self, new_value: &str) -> OrgunitGetCall<'a, C, A> { self._org_unit_path.push(new_value.to_string()); self } @@ -5132,7 +5128,7 @@ impl<'a, C, NC, A> OrgunitGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> OrgunitGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> OrgunitGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5153,7 +5149,7 @@ impl<'a, C, NC, A> OrgunitGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> OrgunitGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> OrgunitGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5170,7 +5166,7 @@ impl<'a, C, NC, A> OrgunitGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> OrgunitGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> OrgunitGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5214,10 +5210,10 @@ impl<'a, C, NC, A> OrgunitGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct OrgunitUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct OrgunitUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: OrgUnit, _customer_id: String, _org_unit_path: Vec, @@ -5226,9 +5222,9 @@ pub struct OrgunitUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for OrgunitUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for OrgunitUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> OrgunitUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> OrgunitUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5374,7 +5370,7 @@ impl<'a, C, NC, A> OrgunitUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &OrgUnit) -> OrgunitUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &OrgUnit) -> OrgunitUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5384,7 +5380,7 @@ impl<'a, C, NC, A> OrgunitUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Immutable id of the Google Apps account - pub fn customer_id(mut self, new_value: &str) -> OrgunitUpdateCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> OrgunitUpdateCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -5395,7 +5391,7 @@ impl<'a, C, NC, A> OrgunitUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Full path of the organization unit or its Id - pub fn add_org_unit_path(mut self, new_value: &str) -> OrgunitUpdateCall<'a, C, NC, A> { + pub fn add_org_unit_path(mut self, new_value: &str) -> OrgunitUpdateCall<'a, C, A> { self._org_unit_path.push(new_value.to_string()); self } @@ -5406,7 +5402,7 @@ impl<'a, C, NC, A> OrgunitUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> OrgunitUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> OrgunitUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5427,7 +5423,7 @@ impl<'a, C, NC, A> OrgunitUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> OrgunitUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> OrgunitUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5444,7 +5440,7 @@ impl<'a, C, NC, A> OrgunitUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> OrgunitUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> OrgunitUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5482,10 +5478,10 @@ impl<'a, C, NC, A> OrgunitUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct OrgunitDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct OrgunitDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _customer_id: String, _org_unit_path: Vec, _delegate: Option<&'a mut Delegate>, @@ -5493,9 +5489,9 @@ pub struct OrgunitDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for OrgunitDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for OrgunitDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> OrgunitDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> OrgunitDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5623,7 +5619,7 @@ impl<'a, C, NC, A> OrgunitDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Immutable id of the Google Apps account - pub fn customer_id(mut self, new_value: &str) -> OrgunitDeleteCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> OrgunitDeleteCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -5634,7 +5630,7 @@ impl<'a, C, NC, A> OrgunitDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Full path of the organization unit or its Id - pub fn add_org_unit_path(mut self, new_value: &str) -> OrgunitDeleteCall<'a, C, NC, A> { + pub fn add_org_unit_path(mut self, new_value: &str) -> OrgunitDeleteCall<'a, C, A> { self._org_unit_path.push(new_value.to_string()); self } @@ -5645,7 +5641,7 @@ impl<'a, C, NC, A> OrgunitDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> OrgunitDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> OrgunitDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5666,7 +5662,7 @@ impl<'a, C, NC, A> OrgunitDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> OrgunitDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> OrgunitDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5683,7 +5679,7 @@ impl<'a, C, NC, A> OrgunitDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> OrgunitDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> OrgunitDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5727,10 +5723,10 @@ impl<'a, C, NC, A> OrgunitDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct OrgunitPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct OrgunitPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: OrgUnit, _customer_id: String, _org_unit_path: Vec, @@ -5739,9 +5735,9 @@ pub struct OrgunitPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for OrgunitPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for OrgunitPatchCall<'a, C, A> {} -impl<'a, C, NC, A> OrgunitPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> OrgunitPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5887,7 +5883,7 @@ impl<'a, C, NC, A> OrgunitPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &OrgUnit) -> OrgunitPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &OrgUnit) -> OrgunitPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5897,7 +5893,7 @@ impl<'a, C, NC, A> OrgunitPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Immutable id of the Google Apps account - pub fn customer_id(mut self, new_value: &str) -> OrgunitPatchCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> OrgunitPatchCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -5908,7 +5904,7 @@ impl<'a, C, NC, A> OrgunitPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Full path of the organization unit or its Id - pub fn add_org_unit_path(mut self, new_value: &str) -> OrgunitPatchCall<'a, C, NC, A> { + pub fn add_org_unit_path(mut self, new_value: &str) -> OrgunitPatchCall<'a, C, A> { self._org_unit_path.push(new_value.to_string()); self } @@ -5919,7 +5915,7 @@ impl<'a, C, NC, A> OrgunitPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> OrgunitPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> OrgunitPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5940,7 +5936,7 @@ impl<'a, C, NC, A> OrgunitPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> OrgunitPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> OrgunitPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5957,7 +5953,7 @@ impl<'a, C, NC, A> OrgunitPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> OrgunitPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> OrgunitPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6001,19 +5997,19 @@ impl<'a, C, NC, A> OrgunitPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct UserInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: User, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserInsertCall<'a, C, A> {} -impl<'a, C, NC, A> UserInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6127,7 +6123,7 @@ impl<'a, C, NC, A> UserInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &User) -> UserInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &User) -> UserInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6138,7 +6134,7 @@ impl<'a, C, NC, A> UserInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6159,7 +6155,7 @@ impl<'a, C, NC, A> UserInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6176,7 +6172,7 @@ impl<'a, C, NC, A> UserInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6214,19 +6210,19 @@ impl<'a, C, NC, A> UserInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct UserPhotoDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserPhotoDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _user_key: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserPhotoDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserPhotoDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> UserPhotoDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserPhotoDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6347,7 +6343,7 @@ impl<'a, C, NC, A> UserPhotoDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Email or immutable Id of the user - pub fn user_key(mut self, new_value: &str) -> UserPhotoDeleteCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> UserPhotoDeleteCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -6358,7 +6354,7 @@ impl<'a, C, NC, A> UserPhotoDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserPhotoDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserPhotoDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6379,7 +6375,7 @@ impl<'a, C, NC, A> UserPhotoDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserPhotoDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserPhotoDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6396,7 +6392,7 @@ impl<'a, C, NC, A> UserPhotoDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserPhotoDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserPhotoDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6440,10 +6436,10 @@ impl<'a, C, NC, A> UserPhotoDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct UserUndeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserUndeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: UserUndelete, _user_key: String, _delegate: Option<&'a mut Delegate>, @@ -6451,9 +6447,9 @@ pub struct UserUndeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserUndeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserUndeleteCall<'a, C, A> {} -impl<'a, C, NC, A> UserUndeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserUndeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6581,7 +6577,7 @@ impl<'a, C, NC, A> UserUndeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &UserUndelete) -> UserUndeleteCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &UserUndelete) -> UserUndeleteCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6591,7 +6587,7 @@ impl<'a, C, NC, A> UserUndeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The immutable id of the user - pub fn user_key(mut self, new_value: &str) -> UserUndeleteCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> UserUndeleteCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -6602,7 +6598,7 @@ impl<'a, C, NC, A> UserUndeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserUndeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserUndeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6623,7 +6619,7 @@ impl<'a, C, NC, A> UserUndeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserUndeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserUndeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6640,7 +6636,7 @@ impl<'a, C, NC, A> UserUndeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserUndeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserUndeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6684,10 +6680,10 @@ impl<'a, C, NC, A> UserUndeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct UserMakeAdminCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserMakeAdminCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: UserMakeAdmin, _user_key: String, _delegate: Option<&'a mut Delegate>, @@ -6695,9 +6691,9 @@ pub struct UserMakeAdminCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserMakeAdminCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserMakeAdminCall<'a, C, A> {} -impl<'a, C, NC, A> UserMakeAdminCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserMakeAdminCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6825,7 +6821,7 @@ impl<'a, C, NC, A> UserMakeAdminCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &UserMakeAdmin) -> UserMakeAdminCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &UserMakeAdmin) -> UserMakeAdminCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6835,7 +6831,7 @@ impl<'a, C, NC, A> UserMakeAdminCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Email or immutable Id of the user as admin - pub fn user_key(mut self, new_value: &str) -> UserMakeAdminCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> UserMakeAdminCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -6846,7 +6842,7 @@ impl<'a, C, NC, A> UserMakeAdminCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserMakeAdminCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserMakeAdminCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6867,7 +6863,7 @@ impl<'a, C, NC, A> UserMakeAdminCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserMakeAdminCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserMakeAdminCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6884,7 +6880,7 @@ impl<'a, C, NC, A> UserMakeAdminCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserMakeAdminCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserMakeAdminCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6928,10 +6924,10 @@ impl<'a, C, NC, A> UserMakeAdminCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct UserPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: User, _user_key: String, _delegate: Option<&'a mut Delegate>, @@ -6939,9 +6935,9 @@ pub struct UserPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserPatchCall<'a, C, A> {} -impl<'a, C, NC, A> UserPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7080,7 +7076,7 @@ impl<'a, C, NC, A> UserPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &User) -> UserPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &User) -> UserPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7090,7 +7086,7 @@ impl<'a, C, NC, A> UserPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Email or immutable Id of the user. If Id, it should match with id of user object - pub fn user_key(mut self, new_value: &str) -> UserPatchCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> UserPatchCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -7101,7 +7097,7 @@ impl<'a, C, NC, A> UserPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7122,7 +7118,7 @@ impl<'a, C, NC, A> UserPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7139,7 +7135,7 @@ impl<'a, C, NC, A> UserPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7195,10 +7191,10 @@ impl<'a, C, NC, A> UserPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct UserWatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserWatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: Channel, _view_type: Option, _sort_order: Option, @@ -7217,9 +7213,9 @@ pub struct UserWatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserWatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserWatchCall<'a, C, A> {} -impl<'a, C, NC, A> UserWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserWatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7369,7 +7365,7 @@ impl<'a, C, NC, A> UserWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Channel) -> UserWatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Channel) -> UserWatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7377,7 +7373,7 @@ impl<'a, C, NC, A> UserWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether to fetch the ADMIN_VIEW or DOMAIN_PUBLIC view of the user. - pub fn view_type(mut self, new_value: &str) -> UserWatchCall<'a, C, NC, A> { + pub fn view_type(mut self, new_value: &str) -> UserWatchCall<'a, C, A> { self._view_type = Some(new_value.to_string()); self } @@ -7385,7 +7381,7 @@ impl<'a, C, NC, A> UserWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether to return results in ascending or descending order. - pub fn sort_order(mut self, new_value: &str) -> UserWatchCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> UserWatchCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -7393,7 +7389,7 @@ impl<'a, C, NC, A> UserWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// If set to true retrieves the list of deleted users. Default is false - pub fn show_deleted(mut self, new_value: &str) -> UserWatchCall<'a, C, NC, A> { + pub fn show_deleted(mut self, new_value: &str) -> UserWatchCall<'a, C, A> { self._show_deleted = Some(new_value.to_string()); self } @@ -7401,7 +7397,7 @@ impl<'a, C, NC, A> UserWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Query string search. Should be of the form "". Complete documentation is at https://developers.google.com/admin-sdk/directory/v1/guides/search-users - pub fn query(mut self, new_value: &str) -> UserWatchCall<'a, C, NC, A> { + pub fn query(mut self, new_value: &str) -> UserWatchCall<'a, C, A> { self._query = Some(new_value.to_string()); self } @@ -7409,7 +7405,7 @@ impl<'a, C, NC, A> UserWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// What subset of fields to fetch for this user. - pub fn projection(mut self, new_value: &str) -> UserWatchCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> UserWatchCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -7417,7 +7413,7 @@ impl<'a, C, NC, A> UserWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Token to specify next page in the list - pub fn page_token(mut self, new_value: &str) -> UserWatchCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> UserWatchCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -7425,7 +7421,7 @@ impl<'a, C, NC, A> UserWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Column to use for sorting results - pub fn order_by(mut self, new_value: &str) -> UserWatchCall<'a, C, NC, A> { + pub fn order_by(mut self, new_value: &str) -> UserWatchCall<'a, C, A> { self._order_by = Some(new_value.to_string()); self } @@ -7433,7 +7429,7 @@ impl<'a, C, NC, A> UserWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Maximum number of results to return. Default is 100. Max allowed is 500 - pub fn max_results(mut self, new_value: i32) -> UserWatchCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> UserWatchCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -7441,7 +7437,7 @@ impl<'a, C, NC, A> UserWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Event on which subscription is intended (if subscribing) - pub fn event(mut self, new_value: &str) -> UserWatchCall<'a, C, NC, A> { + pub fn event(mut self, new_value: &str) -> UserWatchCall<'a, C, A> { self._event = Some(new_value.to_string()); self } @@ -7449,7 +7445,7 @@ impl<'a, C, NC, A> UserWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Name of the domain. Fill this field to get users from only this domain. To return all users in a multi-domain fill customer field instead. - pub fn domain(mut self, new_value: &str) -> UserWatchCall<'a, C, NC, A> { + pub fn domain(mut self, new_value: &str) -> UserWatchCall<'a, C, A> { self._domain = Some(new_value.to_string()); self } @@ -7457,7 +7453,7 @@ impl<'a, C, NC, A> UserWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Immutable id of the Google Apps account. In case of multi-domain, to fetch all users for a customer, fill this field instead of domain. - pub fn customer(mut self, new_value: &str) -> UserWatchCall<'a, C, NC, A> { + pub fn customer(mut self, new_value: &str) -> UserWatchCall<'a, C, A> { self._customer = Some(new_value.to_string()); self } @@ -7465,7 +7461,7 @@ impl<'a, C, NC, A> UserWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Comma-separated list of schema names. All fields from these schemas are fetched. This should only be set when projection=custom. - pub fn custom_field_mask(mut self, new_value: &str) -> UserWatchCall<'a, C, NC, A> { + pub fn custom_field_mask(mut self, new_value: &str) -> UserWatchCall<'a, C, A> { self._custom_field_mask = Some(new_value.to_string()); self } @@ -7476,7 +7472,7 @@ impl<'a, C, NC, A> UserWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserWatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserWatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7497,7 +7493,7 @@ impl<'a, C, NC, A> UserWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserWatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserWatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7514,7 +7510,7 @@ impl<'a, C, NC, A> UserWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserWatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserWatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7552,19 +7548,19 @@ impl<'a, C, NC, A> UserWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct UserDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _user_key: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> UserDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7685,7 +7681,7 @@ impl<'a, C, NC, A> UserDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Email or immutable Id of the user - pub fn user_key(mut self, new_value: &str) -> UserDeleteCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> UserDeleteCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -7696,7 +7692,7 @@ impl<'a, C, NC, A> UserDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7717,7 +7713,7 @@ impl<'a, C, NC, A> UserDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7734,7 +7730,7 @@ impl<'a, C, NC, A> UserDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7778,10 +7774,10 @@ impl<'a, C, NC, A> UserDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct UserPhotoUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserPhotoUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: UserPhoto, _user_key: String, _delegate: Option<&'a mut Delegate>, @@ -7789,9 +7785,9 @@ pub struct UserPhotoUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserPhotoUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserPhotoUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> UserPhotoUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserPhotoUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7930,7 +7926,7 @@ impl<'a, C, NC, A> UserPhotoUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &UserPhoto) -> UserPhotoUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &UserPhoto) -> UserPhotoUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7940,7 +7936,7 @@ impl<'a, C, NC, A> UserPhotoUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Email or immutable Id of the user - pub fn user_key(mut self, new_value: &str) -> UserPhotoUpdateCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> UserPhotoUpdateCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -7951,7 +7947,7 @@ impl<'a, C, NC, A> UserPhotoUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserPhotoUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserPhotoUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7972,7 +7968,7 @@ impl<'a, C, NC, A> UserPhotoUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserPhotoUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserPhotoUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7989,7 +7985,7 @@ impl<'a, C, NC, A> UserPhotoUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserPhotoUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserPhotoUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8030,10 +8026,10 @@ impl<'a, C, NC, A> UserPhotoUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct UserGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _user_key: String, _view_type: Option, _projection: Option, @@ -8043,9 +8039,9 @@ pub struct UserGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserGetCall<'a, C, A> {} -impl<'a, C, NC, A> UserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8186,7 +8182,7 @@ impl<'a, C, NC, A> UserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// Email or immutable Id of the user - pub fn user_key(mut self, new_value: &str) -> UserGetCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> UserGetCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -8194,7 +8190,7 @@ impl<'a, C, NC, A> UserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Whether to fetch the ADMIN_VIEW or DOMAIN_PUBLIC view of the user. - pub fn view_type(mut self, new_value: &str) -> UserGetCall<'a, C, NC, A> { + pub fn view_type(mut self, new_value: &str) -> UserGetCall<'a, C, A> { self._view_type = Some(new_value.to_string()); self } @@ -8202,7 +8198,7 @@ impl<'a, C, NC, A> UserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// What subset of fields to fetch for this user. - pub fn projection(mut self, new_value: &str) -> UserGetCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> UserGetCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -8210,7 +8206,7 @@ impl<'a, C, NC, A> UserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Comma-separated list of schema names. All fields from these schemas are fetched. This should only be set when projection=custom. - pub fn custom_field_mask(mut self, new_value: &str) -> UserGetCall<'a, C, NC, A> { + pub fn custom_field_mask(mut self, new_value: &str) -> UserGetCall<'a, C, A> { self._custom_field_mask = Some(new_value.to_string()); self } @@ -8221,7 +8217,7 @@ impl<'a, C, NC, A> UserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8242,7 +8238,7 @@ impl<'a, C, NC, A> UserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8259,7 +8255,7 @@ impl<'a, C, NC, A> UserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8303,10 +8299,10 @@ impl<'a, C, NC, A> UserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct UserAliaseInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserAliaseInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: Alias, _user_key: String, _delegate: Option<&'a mut Delegate>, @@ -8314,9 +8310,9 @@ pub struct UserAliaseInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserAliaseInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserAliaseInsertCall<'a, C, A> {} -impl<'a, C, NC, A> UserAliaseInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserAliaseInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8455,7 +8451,7 @@ impl<'a, C, NC, A> UserAliaseInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Alias) -> UserAliaseInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Alias) -> UserAliaseInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8465,7 +8461,7 @@ impl<'a, C, NC, A> UserAliaseInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Email or immutable Id of the user - pub fn user_key(mut self, new_value: &str) -> UserAliaseInsertCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> UserAliaseInsertCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -8476,7 +8472,7 @@ impl<'a, C, NC, A> UserAliaseInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserAliaseInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserAliaseInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8497,7 +8493,7 @@ impl<'a, C, NC, A> UserAliaseInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserAliaseInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserAliaseInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8514,7 +8510,7 @@ impl<'a, C, NC, A> UserAliaseInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserAliaseInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserAliaseInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8564,10 +8560,10 @@ impl<'a, C, NC, A> UserAliaseInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct UserListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _view_type: Option, _sort_order: Option, _show_deleted: Option, @@ -8585,9 +8581,9 @@ pub struct UserListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserListCall<'a, C, A> {} -impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8728,7 +8724,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Whether to fetch the ADMIN_VIEW or DOMAIN_PUBLIC view of the user. - pub fn view_type(mut self, new_value: &str) -> UserListCall<'a, C, NC, A> { + pub fn view_type(mut self, new_value: &str) -> UserListCall<'a, C, A> { self._view_type = Some(new_value.to_string()); self } @@ -8736,7 +8732,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Whether to return results in ascending or descending order. - pub fn sort_order(mut self, new_value: &str) -> UserListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> UserListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -8744,7 +8740,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// If set to true retrieves the list of deleted users. Default is false - pub fn show_deleted(mut self, new_value: &str) -> UserListCall<'a, C, NC, A> { + pub fn show_deleted(mut self, new_value: &str) -> UserListCall<'a, C, A> { self._show_deleted = Some(new_value.to_string()); self } @@ -8752,7 +8748,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Query string search. Should be of the form "". Complete documentation is at https://developers.google.com/admin-sdk/directory/v1/guides/search-users - pub fn query(mut self, new_value: &str) -> UserListCall<'a, C, NC, A> { + pub fn query(mut self, new_value: &str) -> UserListCall<'a, C, A> { self._query = Some(new_value.to_string()); self } @@ -8760,7 +8756,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// What subset of fields to fetch for this user. - pub fn projection(mut self, new_value: &str) -> UserListCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> UserListCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -8768,7 +8764,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Token to specify next page in the list - pub fn page_token(mut self, new_value: &str) -> UserListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> UserListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -8776,7 +8772,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Column to use for sorting results - pub fn order_by(mut self, new_value: &str) -> UserListCall<'a, C, NC, A> { + pub fn order_by(mut self, new_value: &str) -> UserListCall<'a, C, A> { self._order_by = Some(new_value.to_string()); self } @@ -8784,7 +8780,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Maximum number of results to return. Default is 100. Max allowed is 500 - pub fn max_results(mut self, new_value: i32) -> UserListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> UserListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -8792,7 +8788,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Event on which subscription is intended (if subscribing) - pub fn event(mut self, new_value: &str) -> UserListCall<'a, C, NC, A> { + pub fn event(mut self, new_value: &str) -> UserListCall<'a, C, A> { self._event = Some(new_value.to_string()); self } @@ -8800,7 +8796,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Name of the domain. Fill this field to get users from only this domain. To return all users in a multi-domain fill customer field instead. - pub fn domain(mut self, new_value: &str) -> UserListCall<'a, C, NC, A> { + pub fn domain(mut self, new_value: &str) -> UserListCall<'a, C, A> { self._domain = Some(new_value.to_string()); self } @@ -8808,7 +8804,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Immutable id of the Google Apps account. In case of multi-domain, to fetch all users for a customer, fill this field instead of domain. - pub fn customer(mut self, new_value: &str) -> UserListCall<'a, C, NC, A> { + pub fn customer(mut self, new_value: &str) -> UserListCall<'a, C, A> { self._customer = Some(new_value.to_string()); self } @@ -8816,7 +8812,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Comma-separated list of schema names. All fields from these schemas are fetched. This should only be set when projection=custom. - pub fn custom_field_mask(mut self, new_value: &str) -> UserListCall<'a, C, NC, A> { + pub fn custom_field_mask(mut self, new_value: &str) -> UserListCall<'a, C, A> { self._custom_field_mask = Some(new_value.to_string()); self } @@ -8827,7 +8823,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8848,7 +8844,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8865,7 +8861,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8903,10 +8899,10 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct UserAliaseDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserAliaseDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _user_key: String, _alias: String, _delegate: Option<&'a mut Delegate>, @@ -8914,9 +8910,9 @@ pub struct UserAliaseDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserAliaseDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserAliaseDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> UserAliaseDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserAliaseDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9038,7 +9034,7 @@ impl<'a, C, NC, A> UserAliaseDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Email or immutable Id of the user - pub fn user_key(mut self, new_value: &str) -> UserAliaseDeleteCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> UserAliaseDeleteCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -9048,7 +9044,7 @@ impl<'a, C, NC, A> UserAliaseDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The alias to be removed - pub fn alias(mut self, new_value: &str) -> UserAliaseDeleteCall<'a, C, NC, A> { + pub fn alias(mut self, new_value: &str) -> UserAliaseDeleteCall<'a, C, A> { self._alias = new_value.to_string(); self } @@ -9059,7 +9055,7 @@ impl<'a, C, NC, A> UserAliaseDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserAliaseDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserAliaseDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9080,7 +9076,7 @@ impl<'a, C, NC, A> UserAliaseDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserAliaseDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserAliaseDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9097,7 +9093,7 @@ impl<'a, C, NC, A> UserAliaseDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserAliaseDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserAliaseDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9141,10 +9137,10 @@ impl<'a, C, NC, A> UserAliaseDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct UserUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: User, _user_key: String, _delegate: Option<&'a mut Delegate>, @@ -9152,9 +9148,9 @@ pub struct UserUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> UserUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9293,7 +9289,7 @@ impl<'a, C, NC, A> UserUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &User) -> UserUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &User) -> UserUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9303,7 +9299,7 @@ impl<'a, C, NC, A> UserUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Email or immutable Id of the user. If Id, it should match with id of user object - pub fn user_key(mut self, new_value: &str) -> UserUpdateCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> UserUpdateCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -9314,7 +9310,7 @@ impl<'a, C, NC, A> UserUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9335,7 +9331,7 @@ impl<'a, C, NC, A> UserUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9352,7 +9348,7 @@ impl<'a, C, NC, A> UserUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9397,10 +9393,10 @@ impl<'a, C, NC, A> UserUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct UserAliaseWatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserAliaseWatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: Channel, _user_key: String, _event: Option, @@ -9409,9 +9405,9 @@ pub struct UserAliaseWatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserAliaseWatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserAliaseWatchCall<'a, C, A> {} -impl<'a, C, NC, A> UserAliaseWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserAliaseWatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9553,7 +9549,7 @@ impl<'a, C, NC, A> UserAliaseWatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Channel) -> UserAliaseWatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Channel) -> UserAliaseWatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9563,7 +9559,7 @@ impl<'a, C, NC, A> UserAliaseWatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Email or immutable Id of the user - pub fn user_key(mut self, new_value: &str) -> UserAliaseWatchCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> UserAliaseWatchCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -9571,7 +9567,7 @@ impl<'a, C, NC, A> UserAliaseWatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Event on which subscription is intended (if subscribing) - pub fn event(mut self, new_value: &str) -> UserAliaseWatchCall<'a, C, NC, A> { + pub fn event(mut self, new_value: &str) -> UserAliaseWatchCall<'a, C, A> { self._event = Some(new_value.to_string()); self } @@ -9582,7 +9578,7 @@ impl<'a, C, NC, A> UserAliaseWatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserAliaseWatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserAliaseWatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9603,7 +9599,7 @@ impl<'a, C, NC, A> UserAliaseWatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserAliaseWatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserAliaseWatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9620,7 +9616,7 @@ impl<'a, C, NC, A> UserAliaseWatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserAliaseWatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserAliaseWatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9659,10 +9655,10 @@ impl<'a, C, NC, A> UserAliaseWatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct UserAliaseListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserAliaseListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _user_key: String, _event: Option, _delegate: Option<&'a mut Delegate>, @@ -9670,9 +9666,9 @@ pub struct UserAliaseListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserAliaseListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserAliaseListCall<'a, C, A> {} -impl<'a, C, NC, A> UserAliaseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserAliaseListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9807,7 +9803,7 @@ impl<'a, C, NC, A> UserAliaseListCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Email or immutable Id of the user - pub fn user_key(mut self, new_value: &str) -> UserAliaseListCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> UserAliaseListCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -9815,7 +9811,7 @@ impl<'a, C, NC, A> UserAliaseListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Event on which subscription is intended (if subscribing) - pub fn event(mut self, new_value: &str) -> UserAliaseListCall<'a, C, NC, A> { + pub fn event(mut self, new_value: &str) -> UserAliaseListCall<'a, C, A> { self._event = Some(new_value.to_string()); self } @@ -9826,7 +9822,7 @@ impl<'a, C, NC, A> UserAliaseListCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserAliaseListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserAliaseListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9847,7 +9843,7 @@ impl<'a, C, NC, A> UserAliaseListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserAliaseListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserAliaseListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9864,7 +9860,7 @@ impl<'a, C, NC, A> UserAliaseListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserAliaseListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserAliaseListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9902,19 +9898,19 @@ impl<'a, C, NC, A> UserAliaseListCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct UserPhotoGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserPhotoGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _user_key: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserPhotoGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserPhotoGetCall<'a, C, A> {} -impl<'a, C, NC, A> UserPhotoGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserPhotoGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10046,7 +10042,7 @@ impl<'a, C, NC, A> UserPhotoGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Email or immutable Id of the user - pub fn user_key(mut self, new_value: &str) -> UserPhotoGetCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> UserPhotoGetCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -10057,7 +10053,7 @@ impl<'a, C, NC, A> UserPhotoGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserPhotoGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserPhotoGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10078,7 +10074,7 @@ impl<'a, C, NC, A> UserPhotoGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserPhotoGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserPhotoGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10095,7 +10091,7 @@ impl<'a, C, NC, A> UserPhotoGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserPhotoGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserPhotoGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10139,10 +10135,10 @@ impl<'a, C, NC, A> UserPhotoGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct UserPhotoPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserPhotoPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: UserPhoto, _user_key: String, _delegate: Option<&'a mut Delegate>, @@ -10150,9 +10146,9 @@ pub struct UserPhotoPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserPhotoPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserPhotoPatchCall<'a, C, A> {} -impl<'a, C, NC, A> UserPhotoPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserPhotoPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10291,7 +10287,7 @@ impl<'a, C, NC, A> UserPhotoPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &UserPhoto) -> UserPhotoPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &UserPhoto) -> UserPhotoPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -10301,7 +10297,7 @@ impl<'a, C, NC, A> UserPhotoPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Email or immutable Id of the user - pub fn user_key(mut self, new_value: &str) -> UserPhotoPatchCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> UserPhotoPatchCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -10312,7 +10308,7 @@ impl<'a, C, NC, A> UserPhotoPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserPhotoPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserPhotoPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10333,7 +10329,7 @@ impl<'a, C, NC, A> UserPhotoPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserPhotoPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserPhotoPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10350,7 +10346,7 @@ impl<'a, C, NC, A> UserPhotoPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserPhotoPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserPhotoPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10388,10 +10384,10 @@ impl<'a, C, NC, A> UserPhotoPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct MobiledeviceDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MobiledeviceDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _customer_id: String, _resource_id: String, _delegate: Option<&'a mut Delegate>, @@ -10399,9 +10395,9 @@ pub struct MobiledeviceDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MobiledeviceDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MobiledeviceDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> MobiledeviceDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MobiledeviceDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10523,7 +10519,7 @@ impl<'a, C, NC, A> MobiledeviceDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Immutable id of the Google Apps account - pub fn customer_id(mut self, new_value: &str) -> MobiledeviceDeleteCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> MobiledeviceDeleteCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -10533,7 +10529,7 @@ impl<'a, C, NC, A> MobiledeviceDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Immutable id of Mobile Device - pub fn resource_id(mut self, new_value: &str) -> MobiledeviceDeleteCall<'a, C, NC, A> { + pub fn resource_id(mut self, new_value: &str) -> MobiledeviceDeleteCall<'a, C, A> { self._resource_id = new_value.to_string(); self } @@ -10544,7 +10540,7 @@ impl<'a, C, NC, A> MobiledeviceDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MobiledeviceDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MobiledeviceDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10565,7 +10561,7 @@ impl<'a, C, NC, A> MobiledeviceDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MobiledeviceDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MobiledeviceDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10582,7 +10578,7 @@ impl<'a, C, NC, A> MobiledeviceDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MobiledeviceDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MobiledeviceDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10621,10 +10617,10 @@ impl<'a, C, NC, A> MobiledeviceDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct MobiledeviceGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MobiledeviceGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _customer_id: String, _resource_id: String, _projection: Option, @@ -10633,9 +10629,9 @@ pub struct MobiledeviceGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MobiledeviceGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MobiledeviceGetCall<'a, C, A> {} -impl<'a, C, NC, A> MobiledeviceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MobiledeviceGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10771,7 +10767,7 @@ impl<'a, C, NC, A> MobiledeviceGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Immutable id of the Google Apps account - pub fn customer_id(mut self, new_value: &str) -> MobiledeviceGetCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> MobiledeviceGetCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -10781,7 +10777,7 @@ impl<'a, C, NC, A> MobiledeviceGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Immutable id of Mobile Device - pub fn resource_id(mut self, new_value: &str) -> MobiledeviceGetCall<'a, C, NC, A> { + pub fn resource_id(mut self, new_value: &str) -> MobiledeviceGetCall<'a, C, A> { self._resource_id = new_value.to_string(); self } @@ -10789,7 +10785,7 @@ impl<'a, C, NC, A> MobiledeviceGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Restrict information returned to a set of selected fields. - pub fn projection(mut self, new_value: &str) -> MobiledeviceGetCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> MobiledeviceGetCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -10800,7 +10796,7 @@ impl<'a, C, NC, A> MobiledeviceGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MobiledeviceGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MobiledeviceGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10821,7 +10817,7 @@ impl<'a, C, NC, A> MobiledeviceGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MobiledeviceGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MobiledeviceGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10838,7 +10834,7 @@ impl<'a, C, NC, A> MobiledeviceGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MobiledeviceGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MobiledeviceGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10882,10 +10878,10 @@ impl<'a, C, NC, A> MobiledeviceGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct MobiledeviceListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MobiledeviceListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _customer_id: String, _sort_order: Option, _query: Option, @@ -10898,9 +10894,9 @@ pub struct MobiledeviceListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MobiledeviceListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MobiledeviceListCall<'a, C, A> {} -impl<'a, C, NC, A> MobiledeviceListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MobiledeviceListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11050,7 +11046,7 @@ impl<'a, C, NC, A> MobiledeviceListCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Immutable id of the Google Apps account - pub fn customer_id(mut self, new_value: &str) -> MobiledeviceListCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> MobiledeviceListCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -11058,7 +11054,7 @@ impl<'a, C, NC, A> MobiledeviceListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Whether to return results in ascending or descending order. Only of use when orderBy is also used - pub fn sort_order(mut self, new_value: &str) -> MobiledeviceListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> MobiledeviceListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -11066,7 +11062,7 @@ impl<'a, C, NC, A> MobiledeviceListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Search string in the format given at http://support.google.com/a/bin/answer.py?hl=en&answer=1408863#search - pub fn query(mut self, new_value: &str) -> MobiledeviceListCall<'a, C, NC, A> { + pub fn query(mut self, new_value: &str) -> MobiledeviceListCall<'a, C, A> { self._query = Some(new_value.to_string()); self } @@ -11074,7 +11070,7 @@ impl<'a, C, NC, A> MobiledeviceListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Restrict information returned to a set of selected fields. - pub fn projection(mut self, new_value: &str) -> MobiledeviceListCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> MobiledeviceListCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -11082,7 +11078,7 @@ impl<'a, C, NC, A> MobiledeviceListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Token to specify next page in the list - pub fn page_token(mut self, new_value: &str) -> MobiledeviceListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> MobiledeviceListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -11090,7 +11086,7 @@ impl<'a, C, NC, A> MobiledeviceListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Column to use for sorting results - pub fn order_by(mut self, new_value: &str) -> MobiledeviceListCall<'a, C, NC, A> { + pub fn order_by(mut self, new_value: &str) -> MobiledeviceListCall<'a, C, A> { self._order_by = Some(new_value.to_string()); self } @@ -11098,7 +11094,7 @@ impl<'a, C, NC, A> MobiledeviceListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Maximum number of results to return. Default is 100 - pub fn max_results(mut self, new_value: i32) -> MobiledeviceListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> MobiledeviceListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -11109,7 +11105,7 @@ impl<'a, C, NC, A> MobiledeviceListCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MobiledeviceListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MobiledeviceListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11130,7 +11126,7 @@ impl<'a, C, NC, A> MobiledeviceListCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MobiledeviceListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MobiledeviceListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11147,7 +11143,7 @@ impl<'a, C, NC, A> MobiledeviceListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MobiledeviceListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MobiledeviceListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11191,10 +11187,10 @@ impl<'a, C, NC, A> MobiledeviceListCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct MobiledeviceActionCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MobiledeviceActionCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: MobileDeviceAction, _customer_id: String, _resource_id: String, @@ -11203,9 +11199,9 @@ pub struct MobiledeviceActionCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MobiledeviceActionCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MobiledeviceActionCall<'a, C, A> {} -impl<'a, C, NC, A> MobiledeviceActionCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MobiledeviceActionCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11334,7 +11330,7 @@ impl<'a, C, NC, A> MobiledeviceActionCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &MobileDeviceAction) -> MobiledeviceActionCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &MobileDeviceAction) -> MobiledeviceActionCall<'a, C, A> { self._request = new_value.clone(); self } @@ -11344,7 +11340,7 @@ impl<'a, C, NC, A> MobiledeviceActionCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Immutable id of the Google Apps account - pub fn customer_id(mut self, new_value: &str) -> MobiledeviceActionCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> MobiledeviceActionCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -11354,7 +11350,7 @@ impl<'a, C, NC, A> MobiledeviceActionCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Immutable id of Mobile Device - pub fn resource_id(mut self, new_value: &str) -> MobiledeviceActionCall<'a, C, NC, A> { + pub fn resource_id(mut self, new_value: &str) -> MobiledeviceActionCall<'a, C, A> { self._resource_id = new_value.to_string(); self } @@ -11365,7 +11361,7 @@ impl<'a, C, NC, A> MobiledeviceActionCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MobiledeviceActionCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MobiledeviceActionCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11386,7 +11382,7 @@ impl<'a, C, NC, A> MobiledeviceActionCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MobiledeviceActionCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MobiledeviceActionCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11403,7 +11399,7 @@ impl<'a, C, NC, A> MobiledeviceActionCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MobiledeviceActionCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MobiledeviceActionCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11447,10 +11443,10 @@ impl<'a, C, NC, A> MobiledeviceActionCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct MemberUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MemberUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: Member, _group_key: String, _member_key: String, @@ -11459,9 +11455,9 @@ pub struct MemberUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MemberUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MemberUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> MemberUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MemberUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11601,7 +11597,7 @@ impl<'a, C, NC, A> MemberUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Member) -> MemberUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Member) -> MemberUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -11611,7 +11607,7 @@ impl<'a, C, NC, A> MemberUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Email or immutable Id of the group. If Id, it should match with id of group object - pub fn group_key(mut self, new_value: &str) -> MemberUpdateCall<'a, C, NC, A> { + pub fn group_key(mut self, new_value: &str) -> MemberUpdateCall<'a, C, A> { self._group_key = new_value.to_string(); self } @@ -11621,7 +11617,7 @@ impl<'a, C, NC, A> MemberUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Email or immutable Id of the user. If Id, it should match with id of member object - pub fn member_key(mut self, new_value: &str) -> MemberUpdateCall<'a, C, NC, A> { + pub fn member_key(mut self, new_value: &str) -> MemberUpdateCall<'a, C, A> { self._member_key = new_value.to_string(); self } @@ -11632,7 +11628,7 @@ impl<'a, C, NC, A> MemberUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MemberUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MemberUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11653,7 +11649,7 @@ impl<'a, C, NC, A> MemberUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MemberUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MemberUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11670,7 +11666,7 @@ impl<'a, C, NC, A> MemberUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MemberUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MemberUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11708,10 +11704,10 @@ impl<'a, C, NC, A> MemberUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct MemberGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MemberGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _group_key: String, _member_key: String, _delegate: Option<&'a mut Delegate>, @@ -11719,9 +11715,9 @@ pub struct MemberGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MemberGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MemberGetCall<'a, C, A> {} -impl<'a, C, NC, A> MemberGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MemberGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11854,7 +11850,7 @@ impl<'a, C, NC, A> MemberGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Email or immutable Id of the group - pub fn group_key(mut self, new_value: &str) -> MemberGetCall<'a, C, NC, A> { + pub fn group_key(mut self, new_value: &str) -> MemberGetCall<'a, C, A> { self._group_key = new_value.to_string(); self } @@ -11864,7 +11860,7 @@ impl<'a, C, NC, A> MemberGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Email or immutable Id of the member - pub fn member_key(mut self, new_value: &str) -> MemberGetCall<'a, C, NC, A> { + pub fn member_key(mut self, new_value: &str) -> MemberGetCall<'a, C, A> { self._member_key = new_value.to_string(); self } @@ -11875,7 +11871,7 @@ impl<'a, C, NC, A> MemberGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MemberGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MemberGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11896,7 +11892,7 @@ impl<'a, C, NC, A> MemberGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MemberGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MemberGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11913,7 +11909,7 @@ impl<'a, C, NC, A> MemberGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MemberGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MemberGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11957,10 +11953,10 @@ impl<'a, C, NC, A> MemberGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct MemberInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MemberInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: Member, _group_key: String, _delegate: Option<&'a mut Delegate>, @@ -11968,9 +11964,9 @@ pub struct MemberInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MemberInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MemberInsertCall<'a, C, A> {} -impl<'a, C, NC, A> MemberInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MemberInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12109,7 +12105,7 @@ impl<'a, C, NC, A> MemberInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Member) -> MemberInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Member) -> MemberInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -12119,7 +12115,7 @@ impl<'a, C, NC, A> MemberInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Email or immutable Id of the group - pub fn group_key(mut self, new_value: &str) -> MemberInsertCall<'a, C, NC, A> { + pub fn group_key(mut self, new_value: &str) -> MemberInsertCall<'a, C, A> { self._group_key = new_value.to_string(); self } @@ -12130,7 +12126,7 @@ impl<'a, C, NC, A> MemberInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MemberInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MemberInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12151,7 +12147,7 @@ impl<'a, C, NC, A> MemberInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MemberInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MemberInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12168,7 +12164,7 @@ impl<'a, C, NC, A> MemberInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MemberInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MemberInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12212,10 +12208,10 @@ impl<'a, C, NC, A> MemberInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct MemberPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MemberPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: Member, _group_key: String, _member_key: String, @@ -12224,9 +12220,9 @@ pub struct MemberPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MemberPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MemberPatchCall<'a, C, A> {} -impl<'a, C, NC, A> MemberPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MemberPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12366,7 +12362,7 @@ impl<'a, C, NC, A> MemberPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Member) -> MemberPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Member) -> MemberPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -12376,7 +12372,7 @@ impl<'a, C, NC, A> MemberPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Email or immutable Id of the group. If Id, it should match with id of group object - pub fn group_key(mut self, new_value: &str) -> MemberPatchCall<'a, C, NC, A> { + pub fn group_key(mut self, new_value: &str) -> MemberPatchCall<'a, C, A> { self._group_key = new_value.to_string(); self } @@ -12386,7 +12382,7 @@ impl<'a, C, NC, A> MemberPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Email or immutable Id of the user. If Id, it should match with id of member object - pub fn member_key(mut self, new_value: &str) -> MemberPatchCall<'a, C, NC, A> { + pub fn member_key(mut self, new_value: &str) -> MemberPatchCall<'a, C, A> { self._member_key = new_value.to_string(); self } @@ -12397,7 +12393,7 @@ impl<'a, C, NC, A> MemberPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MemberPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MemberPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12418,7 +12414,7 @@ impl<'a, C, NC, A> MemberPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MemberPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MemberPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12435,7 +12431,7 @@ impl<'a, C, NC, A> MemberPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MemberPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MemberPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12473,10 +12469,10 @@ impl<'a, C, NC, A> MemberPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct MemberDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MemberDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _group_key: String, _member_key: String, _delegate: Option<&'a mut Delegate>, @@ -12484,9 +12480,9 @@ pub struct MemberDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MemberDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MemberDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> MemberDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MemberDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12608,7 +12604,7 @@ impl<'a, C, NC, A> MemberDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Email or immutable Id of the group - pub fn group_key(mut self, new_value: &str) -> MemberDeleteCall<'a, C, NC, A> { + pub fn group_key(mut self, new_value: &str) -> MemberDeleteCall<'a, C, A> { self._group_key = new_value.to_string(); self } @@ -12618,7 +12614,7 @@ impl<'a, C, NC, A> MemberDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Email or immutable Id of the member - pub fn member_key(mut self, new_value: &str) -> MemberDeleteCall<'a, C, NC, A> { + pub fn member_key(mut self, new_value: &str) -> MemberDeleteCall<'a, C, A> { self._member_key = new_value.to_string(); self } @@ -12629,7 +12625,7 @@ impl<'a, C, NC, A> MemberDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MemberDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MemberDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12650,7 +12646,7 @@ impl<'a, C, NC, A> MemberDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MemberDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MemberDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12667,7 +12663,7 @@ impl<'a, C, NC, A> MemberDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MemberDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MemberDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12708,10 +12704,10 @@ impl<'a, C, NC, A> MemberDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct MemberListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MemberListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _group_key: String, _roles: Option, _page_token: Option, @@ -12721,9 +12717,9 @@ pub struct MemberListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MemberListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MemberListCall<'a, C, A> {} -impl<'a, C, NC, A> MemberListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MemberListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12864,7 +12860,7 @@ impl<'a, C, NC, A> MemberListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Email or immutable Id of the group - pub fn group_key(mut self, new_value: &str) -> MemberListCall<'a, C, NC, A> { + pub fn group_key(mut self, new_value: &str) -> MemberListCall<'a, C, A> { self._group_key = new_value.to_string(); self } @@ -12872,7 +12868,7 @@ impl<'a, C, NC, A> MemberListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Comma separated role values to filter list results on. - pub fn roles(mut self, new_value: &str) -> MemberListCall<'a, C, NC, A> { + pub fn roles(mut self, new_value: &str) -> MemberListCall<'a, C, A> { self._roles = Some(new_value.to_string()); self } @@ -12880,7 +12876,7 @@ impl<'a, C, NC, A> MemberListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Token to specify next page in the list - pub fn page_token(mut self, new_value: &str) -> MemberListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> MemberListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -12888,7 +12884,7 @@ impl<'a, C, NC, A> MemberListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Maximum number of results to return. Default is 200 - pub fn max_results(mut self, new_value: i32) -> MemberListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> MemberListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -12899,7 +12895,7 @@ impl<'a, C, NC, A> MemberListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MemberListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MemberListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12920,7 +12916,7 @@ impl<'a, C, NC, A> MemberListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MemberListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MemberListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12937,7 +12933,7 @@ impl<'a, C, NC, A> MemberListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MemberListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MemberListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12978,10 +12974,10 @@ impl<'a, C, NC, A> MemberListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct NotificationListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct NotificationListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _customer: String, _page_token: Option, _max_results: Option, @@ -12991,9 +12987,9 @@ pub struct NotificationListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for NotificationListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for NotificationListCall<'a, C, A> {} -impl<'a, C, NC, A> NotificationListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> NotificationListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13134,7 +13130,7 @@ impl<'a, C, NC, A> NotificationListCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The unique ID for the customer's Google account. - pub fn customer(mut self, new_value: &str) -> NotificationListCall<'a, C, NC, A> { + pub fn customer(mut self, new_value: &str) -> NotificationListCall<'a, C, A> { self._customer = new_value.to_string(); self } @@ -13142,7 +13138,7 @@ impl<'a, C, NC, A> NotificationListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The token to specify the page of results to retrieve. - pub fn page_token(mut self, new_value: &str) -> NotificationListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> NotificationListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -13150,7 +13146,7 @@ impl<'a, C, NC, A> NotificationListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Maximum number of notifications to return per page. The default is 100. - pub fn max_results(mut self, new_value: u32) -> NotificationListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> NotificationListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -13158,7 +13154,7 @@ impl<'a, C, NC, A> NotificationListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The ISO 639-1 code of the language notifications are returned in. The default is English (en). - pub fn language(mut self, new_value: &str) -> NotificationListCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> NotificationListCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -13169,7 +13165,7 @@ impl<'a, C, NC, A> NotificationListCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> NotificationListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> NotificationListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13190,7 +13186,7 @@ impl<'a, C, NC, A> NotificationListCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> NotificationListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> NotificationListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13207,7 +13203,7 @@ impl<'a, C, NC, A> NotificationListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> NotificationListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> NotificationListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13245,10 +13241,10 @@ impl<'a, C, NC, A> NotificationListCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct NotificationDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct NotificationDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _customer: String, _notification_id: String, _delegate: Option<&'a mut Delegate>, @@ -13256,9 +13252,9 @@ pub struct NotificationDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for NotificationDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for NotificationDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> NotificationDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> NotificationDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13380,7 +13376,7 @@ impl<'a, C, NC, A> NotificationDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The unique ID for the customer's Google account. The customerId is also returned as part of the Users resource. - pub fn customer(mut self, new_value: &str) -> NotificationDeleteCall<'a, C, NC, A> { + pub fn customer(mut self, new_value: &str) -> NotificationDeleteCall<'a, C, A> { self._customer = new_value.to_string(); self } @@ -13390,7 +13386,7 @@ impl<'a, C, NC, A> NotificationDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The unique ID of the notification. - pub fn notification_id(mut self, new_value: &str) -> NotificationDeleteCall<'a, C, NC, A> { + pub fn notification_id(mut self, new_value: &str) -> NotificationDeleteCall<'a, C, A> { self._notification_id = new_value.to_string(); self } @@ -13401,7 +13397,7 @@ impl<'a, C, NC, A> NotificationDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> NotificationDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> NotificationDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13422,7 +13418,7 @@ impl<'a, C, NC, A> NotificationDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> NotificationDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> NotificationDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13439,7 +13435,7 @@ impl<'a, C, NC, A> NotificationDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> NotificationDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> NotificationDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13483,10 +13479,10 @@ impl<'a, C, NC, A> NotificationDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct NotificationPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct NotificationPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: Notification, _customer: String, _notification_id: String, @@ -13495,9 +13491,9 @@ pub struct NotificationPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for NotificationPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for NotificationPatchCall<'a, C, A> {} -impl<'a, C, NC, A> NotificationPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> NotificationPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13637,7 +13633,7 @@ impl<'a, C, NC, A> NotificationPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Notification) -> NotificationPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Notification) -> NotificationPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13647,7 +13643,7 @@ impl<'a, C, NC, A> NotificationPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The unique ID for the customer's Google account. - pub fn customer(mut self, new_value: &str) -> NotificationPatchCall<'a, C, NC, A> { + pub fn customer(mut self, new_value: &str) -> NotificationPatchCall<'a, C, A> { self._customer = new_value.to_string(); self } @@ -13657,7 +13653,7 @@ impl<'a, C, NC, A> NotificationPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The unique ID of the notification. - pub fn notification_id(mut self, new_value: &str) -> NotificationPatchCall<'a, C, NC, A> { + pub fn notification_id(mut self, new_value: &str) -> NotificationPatchCall<'a, C, A> { self._notification_id = new_value.to_string(); self } @@ -13668,7 +13664,7 @@ impl<'a, C, NC, A> NotificationPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> NotificationPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> NotificationPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13689,7 +13685,7 @@ impl<'a, C, NC, A> NotificationPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> NotificationPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> NotificationPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13706,7 +13702,7 @@ impl<'a, C, NC, A> NotificationPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> NotificationPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> NotificationPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13750,10 +13746,10 @@ impl<'a, C, NC, A> NotificationPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct NotificationUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct NotificationUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: Notification, _customer: String, _notification_id: String, @@ -13762,9 +13758,9 @@ pub struct NotificationUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for NotificationUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for NotificationUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> NotificationUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> NotificationUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13904,7 +13900,7 @@ impl<'a, C, NC, A> NotificationUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Notification) -> NotificationUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Notification) -> NotificationUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13914,7 +13910,7 @@ impl<'a, C, NC, A> NotificationUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The unique ID for the customer's Google account. - pub fn customer(mut self, new_value: &str) -> NotificationUpdateCall<'a, C, NC, A> { + pub fn customer(mut self, new_value: &str) -> NotificationUpdateCall<'a, C, A> { self._customer = new_value.to_string(); self } @@ -13924,7 +13920,7 @@ impl<'a, C, NC, A> NotificationUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The unique ID of the notification. - pub fn notification_id(mut self, new_value: &str) -> NotificationUpdateCall<'a, C, NC, A> { + pub fn notification_id(mut self, new_value: &str) -> NotificationUpdateCall<'a, C, A> { self._notification_id = new_value.to_string(); self } @@ -13935,7 +13931,7 @@ impl<'a, C, NC, A> NotificationUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> NotificationUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> NotificationUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13956,7 +13952,7 @@ impl<'a, C, NC, A> NotificationUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> NotificationUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> NotificationUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13973,7 +13969,7 @@ impl<'a, C, NC, A> NotificationUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> NotificationUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> NotificationUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14011,10 +14007,10 @@ impl<'a, C, NC, A> NotificationUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct NotificationGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct NotificationGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _customer: String, _notification_id: String, _delegate: Option<&'a mut Delegate>, @@ -14022,9 +14018,9 @@ pub struct NotificationGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for NotificationGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for NotificationGetCall<'a, C, A> {} -impl<'a, C, NC, A> NotificationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> NotificationGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14157,7 +14153,7 @@ impl<'a, C, NC, A> NotificationGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The unique ID for the customer's Google account. The customerId is also returned as part of the Users resource. - pub fn customer(mut self, new_value: &str) -> NotificationGetCall<'a, C, NC, A> { + pub fn customer(mut self, new_value: &str) -> NotificationGetCall<'a, C, A> { self._customer = new_value.to_string(); self } @@ -14167,7 +14163,7 @@ impl<'a, C, NC, A> NotificationGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The unique ID of the notification. - pub fn notification_id(mut self, new_value: &str) -> NotificationGetCall<'a, C, NC, A> { + pub fn notification_id(mut self, new_value: &str) -> NotificationGetCall<'a, C, A> { self._notification_id = new_value.to_string(); self } @@ -14178,7 +14174,7 @@ impl<'a, C, NC, A> NotificationGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> NotificationGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> NotificationGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14199,7 +14195,7 @@ impl<'a, C, NC, A> NotificationGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> NotificationGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> NotificationGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14216,7 +14212,7 @@ impl<'a, C, NC, A> NotificationGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> NotificationGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> NotificationGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14260,10 +14256,10 @@ impl<'a, C, NC, A> NotificationGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct ChromeosdeviceListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChromeosdeviceListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _customer_id: String, _sort_order: Option, _query: Option, @@ -14276,9 +14272,9 @@ pub struct ChromeosdeviceListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChromeosdeviceListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChromeosdeviceListCall<'a, C, A> {} -impl<'a, C, NC, A> ChromeosdeviceListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChromeosdeviceListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14428,7 +14424,7 @@ impl<'a, C, NC, A> ChromeosdeviceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Immutable id of the Google Apps account - pub fn customer_id(mut self, new_value: &str) -> ChromeosdeviceListCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> ChromeosdeviceListCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -14436,7 +14432,7 @@ impl<'a, C, NC, A> ChromeosdeviceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Whether to return results in ascending or descending order. Only of use when orderBy is also used - pub fn sort_order(mut self, new_value: &str) -> ChromeosdeviceListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> ChromeosdeviceListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -14444,7 +14440,7 @@ impl<'a, C, NC, A> ChromeosdeviceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Search string in the format given at http://support.google.com/chromeos/a/bin/answer.py?hl=en&answer=1698333 - pub fn query(mut self, new_value: &str) -> ChromeosdeviceListCall<'a, C, NC, A> { + pub fn query(mut self, new_value: &str) -> ChromeosdeviceListCall<'a, C, A> { self._query = Some(new_value.to_string()); self } @@ -14452,7 +14448,7 @@ impl<'a, C, NC, A> ChromeosdeviceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Restrict information returned to a set of selected fields. - pub fn projection(mut self, new_value: &str) -> ChromeosdeviceListCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> ChromeosdeviceListCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -14460,7 +14456,7 @@ impl<'a, C, NC, A> ChromeosdeviceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Token to specify next page in the list - pub fn page_token(mut self, new_value: &str) -> ChromeosdeviceListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ChromeosdeviceListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -14468,7 +14464,7 @@ impl<'a, C, NC, A> ChromeosdeviceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Column to use for sorting results - pub fn order_by(mut self, new_value: &str) -> ChromeosdeviceListCall<'a, C, NC, A> { + pub fn order_by(mut self, new_value: &str) -> ChromeosdeviceListCall<'a, C, A> { self._order_by = Some(new_value.to_string()); self } @@ -14476,7 +14472,7 @@ impl<'a, C, NC, A> ChromeosdeviceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Maximum number of results to return. Default is 100 - pub fn max_results(mut self, new_value: i32) -> ChromeosdeviceListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ChromeosdeviceListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -14487,7 +14483,7 @@ impl<'a, C, NC, A> ChromeosdeviceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChromeosdeviceListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChromeosdeviceListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14508,7 +14504,7 @@ impl<'a, C, NC, A> ChromeosdeviceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChromeosdeviceListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChromeosdeviceListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14525,7 +14521,7 @@ impl<'a, C, NC, A> ChromeosdeviceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChromeosdeviceListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChromeosdeviceListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14570,10 +14566,10 @@ impl<'a, C, NC, A> ChromeosdeviceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct ChromeosdevicePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChromeosdevicePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: ChromeOsDevice, _customer_id: String, _device_id: String, @@ -14583,9 +14579,9 @@ pub struct ChromeosdevicePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChromeosdevicePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChromeosdevicePatchCall<'a, C, A> {} -impl<'a, C, NC, A> ChromeosdevicePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChromeosdevicePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14728,7 +14724,7 @@ impl<'a, C, NC, A> ChromeosdevicePatchCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ChromeOsDevice) -> ChromeosdevicePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ChromeOsDevice) -> ChromeosdevicePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -14738,7 +14734,7 @@ impl<'a, C, NC, A> ChromeosdevicePatchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Immutable id of the Google Apps account - pub fn customer_id(mut self, new_value: &str) -> ChromeosdevicePatchCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> ChromeosdevicePatchCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -14748,7 +14744,7 @@ impl<'a, C, NC, A> ChromeosdevicePatchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Immutable id of Chrome OS Device - pub fn device_id(mut self, new_value: &str) -> ChromeosdevicePatchCall<'a, C, NC, A> { + pub fn device_id(mut self, new_value: &str) -> ChromeosdevicePatchCall<'a, C, A> { self._device_id = new_value.to_string(); self } @@ -14756,7 +14752,7 @@ impl<'a, C, NC, A> ChromeosdevicePatchCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Restrict information returned to a set of selected fields. - pub fn projection(mut self, new_value: &str) -> ChromeosdevicePatchCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> ChromeosdevicePatchCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -14767,7 +14763,7 @@ impl<'a, C, NC, A> ChromeosdevicePatchCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChromeosdevicePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChromeosdevicePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14788,7 +14784,7 @@ impl<'a, C, NC, A> ChromeosdevicePatchCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChromeosdevicePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChromeosdevicePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14805,7 +14801,7 @@ impl<'a, C, NC, A> ChromeosdevicePatchCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChromeosdevicePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChromeosdevicePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14844,10 +14840,10 @@ impl<'a, C, NC, A> ChromeosdevicePatchCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct ChromeosdeviceGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChromeosdeviceGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _customer_id: String, _device_id: String, _projection: Option, @@ -14856,9 +14852,9 @@ pub struct ChromeosdeviceGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChromeosdeviceGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChromeosdeviceGetCall<'a, C, A> {} -impl<'a, C, NC, A> ChromeosdeviceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChromeosdeviceGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14994,7 +14990,7 @@ impl<'a, C, NC, A> ChromeosdeviceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Immutable id of the Google Apps account - pub fn customer_id(mut self, new_value: &str) -> ChromeosdeviceGetCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> ChromeosdeviceGetCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -15004,7 +15000,7 @@ impl<'a, C, NC, A> ChromeosdeviceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Immutable id of Chrome OS Device - pub fn device_id(mut self, new_value: &str) -> ChromeosdeviceGetCall<'a, C, NC, A> { + pub fn device_id(mut self, new_value: &str) -> ChromeosdeviceGetCall<'a, C, A> { self._device_id = new_value.to_string(); self } @@ -15012,7 +15008,7 @@ impl<'a, C, NC, A> ChromeosdeviceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Restrict information returned to a set of selected fields. - pub fn projection(mut self, new_value: &str) -> ChromeosdeviceGetCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> ChromeosdeviceGetCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -15023,7 +15019,7 @@ impl<'a, C, NC, A> ChromeosdeviceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChromeosdeviceGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChromeosdeviceGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15044,7 +15040,7 @@ impl<'a, C, NC, A> ChromeosdeviceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChromeosdeviceGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChromeosdeviceGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15061,7 +15057,7 @@ impl<'a, C, NC, A> ChromeosdeviceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChromeosdeviceGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChromeosdeviceGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15106,10 +15102,10 @@ impl<'a, C, NC, A> ChromeosdeviceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct ChromeosdeviceUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChromeosdeviceUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: ChromeOsDevice, _customer_id: String, _device_id: String, @@ -15119,9 +15115,9 @@ pub struct ChromeosdeviceUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChromeosdeviceUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChromeosdeviceUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ChromeosdeviceUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChromeosdeviceUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15264,7 +15260,7 @@ impl<'a, C, NC, A> ChromeosdeviceUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ChromeOsDevice) -> ChromeosdeviceUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ChromeOsDevice) -> ChromeosdeviceUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -15274,7 +15270,7 @@ impl<'a, C, NC, A> ChromeosdeviceUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Immutable id of the Google Apps account - pub fn customer_id(mut self, new_value: &str) -> ChromeosdeviceUpdateCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> ChromeosdeviceUpdateCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -15284,7 +15280,7 @@ impl<'a, C, NC, A> ChromeosdeviceUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Immutable id of Chrome OS Device - pub fn device_id(mut self, new_value: &str) -> ChromeosdeviceUpdateCall<'a, C, NC, A> { + pub fn device_id(mut self, new_value: &str) -> ChromeosdeviceUpdateCall<'a, C, A> { self._device_id = new_value.to_string(); self } @@ -15292,7 +15288,7 @@ impl<'a, C, NC, A> ChromeosdeviceUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// Restrict information returned to a set of selected fields. - pub fn projection(mut self, new_value: &str) -> ChromeosdeviceUpdateCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> ChromeosdeviceUpdateCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -15303,7 +15299,7 @@ impl<'a, C, NC, A> ChromeosdeviceUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChromeosdeviceUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChromeosdeviceUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15324,7 +15320,7 @@ impl<'a, C, NC, A> ChromeosdeviceUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChromeosdeviceUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChromeosdeviceUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15341,7 +15337,7 @@ impl<'a, C, NC, A> ChromeosdeviceUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChromeosdeviceUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChromeosdeviceUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15379,19 +15375,19 @@ impl<'a, C, NC, A> ChromeosdeviceUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct VerificationCodeGenerateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VerificationCodeGenerateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _user_key: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VerificationCodeGenerateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VerificationCodeGenerateCall<'a, C, A> {} -impl<'a, C, NC, A> VerificationCodeGenerateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VerificationCodeGenerateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15512,7 +15508,7 @@ impl<'a, C, NC, A> VerificationCodeGenerateCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Email or immutable Id of the user - pub fn user_key(mut self, new_value: &str) -> VerificationCodeGenerateCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> VerificationCodeGenerateCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -15523,7 +15519,7 @@ impl<'a, C, NC, A> VerificationCodeGenerateCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VerificationCodeGenerateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VerificationCodeGenerateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15544,7 +15540,7 @@ impl<'a, C, NC, A> VerificationCodeGenerateCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VerificationCodeGenerateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VerificationCodeGenerateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15561,7 +15557,7 @@ impl<'a, C, NC, A> VerificationCodeGenerateCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VerificationCodeGenerateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VerificationCodeGenerateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15599,19 +15595,19 @@ impl<'a, C, NC, A> VerificationCodeGenerateCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct VerificationCodeInvalidateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VerificationCodeInvalidateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _user_key: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VerificationCodeInvalidateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VerificationCodeInvalidateCall<'a, C, A> {} -impl<'a, C, NC, A> VerificationCodeInvalidateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VerificationCodeInvalidateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15732,7 +15728,7 @@ impl<'a, C, NC, A> VerificationCodeInvalidateCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Email or immutable Id of the user - pub fn user_key(mut self, new_value: &str) -> VerificationCodeInvalidateCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> VerificationCodeInvalidateCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -15743,7 +15739,7 @@ impl<'a, C, NC, A> VerificationCodeInvalidateCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VerificationCodeInvalidateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VerificationCodeInvalidateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15764,7 +15760,7 @@ impl<'a, C, NC, A> VerificationCodeInvalidateCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VerificationCodeInvalidateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VerificationCodeInvalidateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15781,7 +15777,7 @@ impl<'a, C, NC, A> VerificationCodeInvalidateCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VerificationCodeInvalidateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VerificationCodeInvalidateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15819,19 +15815,19 @@ impl<'a, C, NC, A> VerificationCodeInvalidateCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct VerificationCodeListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VerificationCodeListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _user_key: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VerificationCodeListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VerificationCodeListCall<'a, C, A> {} -impl<'a, C, NC, A> VerificationCodeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VerificationCodeListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15963,7 +15959,7 @@ impl<'a, C, NC, A> VerificationCodeListCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID. - pub fn user_key(mut self, new_value: &str) -> VerificationCodeListCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> VerificationCodeListCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -15974,7 +15970,7 @@ impl<'a, C, NC, A> VerificationCodeListCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VerificationCodeListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VerificationCodeListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15995,7 +15991,7 @@ impl<'a, C, NC, A> VerificationCodeListCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VerificationCodeListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VerificationCodeListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16012,7 +16008,7 @@ impl<'a, C, NC, A> VerificationCodeListCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VerificationCodeListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VerificationCodeListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16050,19 +16046,19 @@ impl<'a, C, NC, A> VerificationCodeListCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct GroupGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GroupGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _group_key: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GroupGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GroupGetCall<'a, C, A> {} -impl<'a, C, NC, A> GroupGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GroupGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16194,7 +16190,7 @@ impl<'a, C, NC, A> GroupGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Email or immutable Id of the group - pub fn group_key(mut self, new_value: &str) -> GroupGetCall<'a, C, NC, A> { + pub fn group_key(mut self, new_value: &str) -> GroupGetCall<'a, C, A> { self._group_key = new_value.to_string(); self } @@ -16205,7 +16201,7 @@ impl<'a, C, NC, A> GroupGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16226,7 +16222,7 @@ impl<'a, C, NC, A> GroupGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GroupGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GroupGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16243,7 +16239,7 @@ impl<'a, C, NC, A> GroupGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GroupGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GroupGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16286,10 +16282,10 @@ impl<'a, C, NC, A> GroupGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct GroupListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GroupListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _user_key: Option, _page_token: Option, _max_results: Option, @@ -16300,9 +16296,9 @@ pub struct GroupListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GroupListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GroupListCall<'a, C, A> {} -impl<'a, C, NC, A> GroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GroupListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16422,7 +16418,7 @@ impl<'a, C, NC, A> GroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Email or immutable Id of the user if only those groups are to be listed, the given user is a member of. If Id, it should match with id of user object - pub fn user_key(mut self, new_value: &str) -> GroupListCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> GroupListCall<'a, C, A> { self._user_key = Some(new_value.to_string()); self } @@ -16430,7 +16426,7 @@ impl<'a, C, NC, A> GroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Token to specify next page in the list - pub fn page_token(mut self, new_value: &str) -> GroupListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> GroupListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -16438,7 +16434,7 @@ impl<'a, C, NC, A> GroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Maximum number of results to return. Default is 200 - pub fn max_results(mut self, new_value: i32) -> GroupListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> GroupListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -16446,7 +16442,7 @@ impl<'a, C, NC, A> GroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Name of the domain. Fill this field to get groups from only this domain. To return all groups in a multi-domain fill customer field instead. - pub fn domain(mut self, new_value: &str) -> GroupListCall<'a, C, NC, A> { + pub fn domain(mut self, new_value: &str) -> GroupListCall<'a, C, A> { self._domain = Some(new_value.to_string()); self } @@ -16454,7 +16450,7 @@ impl<'a, C, NC, A> GroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Immutable id of the Google Apps account. In case of multi-domain, to fetch all groups for a customer, fill this field instead of domain. - pub fn customer(mut self, new_value: &str) -> GroupListCall<'a, C, NC, A> { + pub fn customer(mut self, new_value: &str) -> GroupListCall<'a, C, A> { self._customer = Some(new_value.to_string()); self } @@ -16465,7 +16461,7 @@ impl<'a, C, NC, A> GroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16486,7 +16482,7 @@ impl<'a, C, NC, A> GroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GroupListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GroupListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16503,7 +16499,7 @@ impl<'a, C, NC, A> GroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GroupListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GroupListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16541,19 +16537,19 @@ impl<'a, C, NC, A> GroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct GroupAliaseListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GroupAliaseListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _group_key: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GroupAliaseListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GroupAliaseListCall<'a, C, A> {} -impl<'a, C, NC, A> GroupAliaseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GroupAliaseListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16685,7 +16681,7 @@ impl<'a, C, NC, A> GroupAliaseListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Email or immutable Id of the group - pub fn group_key(mut self, new_value: &str) -> GroupAliaseListCall<'a, C, NC, A> { + pub fn group_key(mut self, new_value: &str) -> GroupAliaseListCall<'a, C, A> { self._group_key = new_value.to_string(); self } @@ -16696,7 +16692,7 @@ impl<'a, C, NC, A> GroupAliaseListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupAliaseListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupAliaseListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16717,7 +16713,7 @@ impl<'a, C, NC, A> GroupAliaseListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GroupAliaseListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GroupAliaseListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16734,7 +16730,7 @@ impl<'a, C, NC, A> GroupAliaseListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GroupAliaseListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GroupAliaseListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16778,10 +16774,10 @@ impl<'a, C, NC, A> GroupAliaseListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct GroupPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GroupPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: Group, _group_key: String, _delegate: Option<&'a mut Delegate>, @@ -16789,9 +16785,9 @@ pub struct GroupPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GroupPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GroupPatchCall<'a, C, A> {} -impl<'a, C, NC, A> GroupPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GroupPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16930,7 +16926,7 @@ impl<'a, C, NC, A> GroupPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Group) -> GroupPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Group) -> GroupPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -16940,7 +16936,7 @@ impl<'a, C, NC, A> GroupPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Email or immutable Id of the group. If Id, it should match with id of group object - pub fn group_key(mut self, new_value: &str) -> GroupPatchCall<'a, C, NC, A> { + pub fn group_key(mut self, new_value: &str) -> GroupPatchCall<'a, C, A> { self._group_key = new_value.to_string(); self } @@ -16951,7 +16947,7 @@ impl<'a, C, NC, A> GroupPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16972,7 +16968,7 @@ impl<'a, C, NC, A> GroupPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GroupPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GroupPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16989,7 +16985,7 @@ impl<'a, C, NC, A> GroupPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GroupPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GroupPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17033,10 +17029,10 @@ impl<'a, C, NC, A> GroupPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct GroupUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GroupUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: Group, _group_key: String, _delegate: Option<&'a mut Delegate>, @@ -17044,9 +17040,9 @@ pub struct GroupUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GroupUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GroupUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> GroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GroupUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17185,7 +17181,7 @@ impl<'a, C, NC, A> GroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Group) -> GroupUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Group) -> GroupUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -17195,7 +17191,7 @@ impl<'a, C, NC, A> GroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Email or immutable Id of the group. If Id, it should match with id of group object - pub fn group_key(mut self, new_value: &str) -> GroupUpdateCall<'a, C, NC, A> { + pub fn group_key(mut self, new_value: &str) -> GroupUpdateCall<'a, C, A> { self._group_key = new_value.to_string(); self } @@ -17206,7 +17202,7 @@ impl<'a, C, NC, A> GroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17227,7 +17223,7 @@ impl<'a, C, NC, A> GroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GroupUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GroupUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17244,7 +17240,7 @@ impl<'a, C, NC, A> GroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GroupUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GroupUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17282,19 +17278,19 @@ impl<'a, C, NC, A> GroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct GroupDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GroupDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _group_key: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GroupDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GroupDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> GroupDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GroupDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17415,7 +17411,7 @@ impl<'a, C, NC, A> GroupDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Email or immutable Id of the group - pub fn group_key(mut self, new_value: &str) -> GroupDeleteCall<'a, C, NC, A> { + pub fn group_key(mut self, new_value: &str) -> GroupDeleteCall<'a, C, A> { self._group_key = new_value.to_string(); self } @@ -17426,7 +17422,7 @@ impl<'a, C, NC, A> GroupDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17447,7 +17443,7 @@ impl<'a, C, NC, A> GroupDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GroupDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GroupDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17464,7 +17460,7 @@ impl<'a, C, NC, A> GroupDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GroupDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GroupDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17508,10 +17504,10 @@ impl<'a, C, NC, A> GroupDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct GroupAliaseInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GroupAliaseInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: Alias, _group_key: String, _delegate: Option<&'a mut Delegate>, @@ -17519,9 +17515,9 @@ pub struct GroupAliaseInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GroupAliaseInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GroupAliaseInsertCall<'a, C, A> {} -impl<'a, C, NC, A> GroupAliaseInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GroupAliaseInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17660,7 +17656,7 @@ impl<'a, C, NC, A> GroupAliaseInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Alias) -> GroupAliaseInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Alias) -> GroupAliaseInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -17670,7 +17666,7 @@ impl<'a, C, NC, A> GroupAliaseInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Email or immutable Id of the group - pub fn group_key(mut self, new_value: &str) -> GroupAliaseInsertCall<'a, C, NC, A> { + pub fn group_key(mut self, new_value: &str) -> GroupAliaseInsertCall<'a, C, A> { self._group_key = new_value.to_string(); self } @@ -17681,7 +17677,7 @@ impl<'a, C, NC, A> GroupAliaseInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupAliaseInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupAliaseInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17702,7 +17698,7 @@ impl<'a, C, NC, A> GroupAliaseInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GroupAliaseInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GroupAliaseInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17719,7 +17715,7 @@ impl<'a, C, NC, A> GroupAliaseInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GroupAliaseInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GroupAliaseInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17757,10 +17753,10 @@ impl<'a, C, NC, A> GroupAliaseInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct GroupAliaseDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GroupAliaseDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _group_key: String, _alias: String, _delegate: Option<&'a mut Delegate>, @@ -17768,9 +17764,9 @@ pub struct GroupAliaseDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GroupAliaseDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GroupAliaseDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> GroupAliaseDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GroupAliaseDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17892,7 +17888,7 @@ impl<'a, C, NC, A> GroupAliaseDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Email or immutable Id of the group - pub fn group_key(mut self, new_value: &str) -> GroupAliaseDeleteCall<'a, C, NC, A> { + pub fn group_key(mut self, new_value: &str) -> GroupAliaseDeleteCall<'a, C, A> { self._group_key = new_value.to_string(); self } @@ -17902,7 +17898,7 @@ impl<'a, C, NC, A> GroupAliaseDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The alias to be removed - pub fn alias(mut self, new_value: &str) -> GroupAliaseDeleteCall<'a, C, NC, A> { + pub fn alias(mut self, new_value: &str) -> GroupAliaseDeleteCall<'a, C, A> { self._alias = new_value.to_string(); self } @@ -17913,7 +17909,7 @@ impl<'a, C, NC, A> GroupAliaseDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupAliaseDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupAliaseDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17934,7 +17930,7 @@ impl<'a, C, NC, A> GroupAliaseDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GroupAliaseDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GroupAliaseDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17951,7 +17947,7 @@ impl<'a, C, NC, A> GroupAliaseDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GroupAliaseDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GroupAliaseDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17995,19 +17991,19 @@ impl<'a, C, NC, A> GroupAliaseDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct GroupInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GroupInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: Group, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GroupInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GroupInsertCall<'a, C, A> {} -impl<'a, C, NC, A> GroupInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GroupInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18121,7 +18117,7 @@ impl<'a, C, NC, A> GroupInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Group) -> GroupInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Group) -> GroupInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -18132,7 +18128,7 @@ impl<'a, C, NC, A> GroupInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18153,7 +18149,7 @@ impl<'a, C, NC, A> GroupInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GroupInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GroupInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18170,7 +18166,7 @@ impl<'a, C, NC, A> GroupInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GroupInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GroupInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18208,10 +18204,10 @@ impl<'a, C, NC, A> GroupInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct AspDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AspDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _user_key: String, _code_id: i32, _delegate: Option<&'a mut Delegate>, @@ -18219,9 +18215,9 @@ pub struct AspDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AspDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AspDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> AspDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AspDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18343,7 +18339,7 @@ impl<'a, C, NC, A> AspDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID. - pub fn user_key(mut self, new_value: &str) -> AspDeleteCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> AspDeleteCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -18353,7 +18349,7 @@ impl<'a, C, NC, A> AspDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The unique ID of the ASP to be deleted. - pub fn code_id(mut self, new_value: i32) -> AspDeleteCall<'a, C, NC, A> { + pub fn code_id(mut self, new_value: i32) -> AspDeleteCall<'a, C, A> { self._code_id = new_value; self } @@ -18364,7 +18360,7 @@ impl<'a, C, NC, A> AspDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AspDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AspDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18385,7 +18381,7 @@ impl<'a, C, NC, A> AspDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AspDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AspDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18402,7 +18398,7 @@ impl<'a, C, NC, A> AspDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AspDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AspDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18440,19 +18436,19 @@ impl<'a, C, NC, A> AspDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct AspListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AspListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _user_key: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AspListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AspListCall<'a, C, A> {} -impl<'a, C, NC, A> AspListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AspListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18584,7 +18580,7 @@ impl<'a, C, NC, A> AspListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID. - pub fn user_key(mut self, new_value: &str) -> AspListCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> AspListCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -18595,7 +18591,7 @@ impl<'a, C, NC, A> AspListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AspListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AspListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18616,7 +18612,7 @@ impl<'a, C, NC, A> AspListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AspListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AspListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18633,7 +18629,7 @@ impl<'a, C, NC, A> AspListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AspListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AspListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18671,10 +18667,10 @@ impl<'a, C, NC, A> AspListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct AspGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AspGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _user_key: String, _code_id: i32, _delegate: Option<&'a mut Delegate>, @@ -18682,9 +18678,9 @@ pub struct AspGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AspGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AspGetCall<'a, C, A> {} -impl<'a, C, NC, A> AspGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AspGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18817,7 +18813,7 @@ impl<'a, C, NC, A> AspGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// we provide this method for API completeness. /// /// Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID. - pub fn user_key(mut self, new_value: &str) -> AspGetCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> AspGetCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -18827,7 +18823,7 @@ impl<'a, C, NC, A> AspGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// we provide this method for API completeness. /// /// The unique ID of the ASP. - pub fn code_id(mut self, new_value: i32) -> AspGetCall<'a, C, NC, A> { + pub fn code_id(mut self, new_value: i32) -> AspGetCall<'a, C, A> { self._code_id = new_value; self } @@ -18838,7 +18834,7 @@ impl<'a, C, NC, A> AspGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AspGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AspGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18859,7 +18855,7 @@ impl<'a, C, NC, A> AspGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AspGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AspGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18876,7 +18872,7 @@ impl<'a, C, NC, A> AspGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AspGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AspGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18914,19 +18910,19 @@ impl<'a, C, NC, A> AspGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// .doit(); /// # } /// ``` -pub struct SchemaListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SchemaListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _customer_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SchemaListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SchemaListCall<'a, C, A> {} -impl<'a, C, NC, A> SchemaListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SchemaListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19058,7 +19054,7 @@ impl<'a, C, NC, A> SchemaListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Immutable id of the Google Apps account - pub fn customer_id(mut self, new_value: &str) -> SchemaListCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> SchemaListCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -19069,7 +19065,7 @@ impl<'a, C, NC, A> SchemaListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SchemaListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SchemaListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19090,7 +19086,7 @@ impl<'a, C, NC, A> SchemaListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SchemaListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SchemaListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19107,7 +19103,7 @@ impl<'a, C, NC, A> SchemaListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SchemaListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SchemaListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19145,10 +19141,10 @@ impl<'a, C, NC, A> SchemaListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct SchemaGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SchemaGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _customer_id: String, _schema_key: String, _delegate: Option<&'a mut Delegate>, @@ -19156,9 +19152,9 @@ pub struct SchemaGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SchemaGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SchemaGetCall<'a, C, A> {} -impl<'a, C, NC, A> SchemaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SchemaGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19291,7 +19287,7 @@ impl<'a, C, NC, A> SchemaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Immutable id of the Google Apps account - pub fn customer_id(mut self, new_value: &str) -> SchemaGetCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> SchemaGetCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -19301,7 +19297,7 @@ impl<'a, C, NC, A> SchemaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Name or immutable Id of the schema - pub fn schema_key(mut self, new_value: &str) -> SchemaGetCall<'a, C, NC, A> { + pub fn schema_key(mut self, new_value: &str) -> SchemaGetCall<'a, C, A> { self._schema_key = new_value.to_string(); self } @@ -19312,7 +19308,7 @@ impl<'a, C, NC, A> SchemaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SchemaGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SchemaGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19333,7 +19329,7 @@ impl<'a, C, NC, A> SchemaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SchemaGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SchemaGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19350,7 +19346,7 @@ impl<'a, C, NC, A> SchemaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SchemaGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SchemaGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19394,10 +19390,10 @@ impl<'a, C, NC, A> SchemaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct SchemaPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SchemaPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: Schema, _customer_id: String, _schema_key: String, @@ -19406,9 +19402,9 @@ pub struct SchemaPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SchemaPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SchemaPatchCall<'a, C, A> {} -impl<'a, C, NC, A> SchemaPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SchemaPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19548,7 +19544,7 @@ impl<'a, C, NC, A> SchemaPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Schema) -> SchemaPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Schema) -> SchemaPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -19558,7 +19554,7 @@ impl<'a, C, NC, A> SchemaPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Immutable id of the Google Apps account - pub fn customer_id(mut self, new_value: &str) -> SchemaPatchCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> SchemaPatchCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -19568,7 +19564,7 @@ impl<'a, C, NC, A> SchemaPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Name or immutable Id of the schema. - pub fn schema_key(mut self, new_value: &str) -> SchemaPatchCall<'a, C, NC, A> { + pub fn schema_key(mut self, new_value: &str) -> SchemaPatchCall<'a, C, A> { self._schema_key = new_value.to_string(); self } @@ -19579,7 +19575,7 @@ impl<'a, C, NC, A> SchemaPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SchemaPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SchemaPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19600,7 +19596,7 @@ impl<'a, C, NC, A> SchemaPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SchemaPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SchemaPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19617,7 +19613,7 @@ impl<'a, C, NC, A> SchemaPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SchemaPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SchemaPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19661,10 +19657,10 @@ impl<'a, C, NC, A> SchemaPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct SchemaInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SchemaInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: Schema, _customer_id: String, _delegate: Option<&'a mut Delegate>, @@ -19672,9 +19668,9 @@ pub struct SchemaInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SchemaInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SchemaInsertCall<'a, C, A> {} -impl<'a, C, NC, A> SchemaInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SchemaInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19813,7 +19809,7 @@ impl<'a, C, NC, A> SchemaInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Schema) -> SchemaInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Schema) -> SchemaInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -19823,7 +19819,7 @@ impl<'a, C, NC, A> SchemaInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Immutable id of the Google Apps account - pub fn customer_id(mut self, new_value: &str) -> SchemaInsertCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> SchemaInsertCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -19834,7 +19830,7 @@ impl<'a, C, NC, A> SchemaInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SchemaInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SchemaInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19855,7 +19851,7 @@ impl<'a, C, NC, A> SchemaInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SchemaInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SchemaInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19872,7 +19868,7 @@ impl<'a, C, NC, A> SchemaInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SchemaInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SchemaInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19910,10 +19906,10 @@ impl<'a, C, NC, A> SchemaInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct SchemaDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SchemaDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _customer_id: String, _schema_key: String, _delegate: Option<&'a mut Delegate>, @@ -19921,9 +19917,9 @@ pub struct SchemaDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SchemaDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SchemaDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> SchemaDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SchemaDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -20045,7 +20041,7 @@ impl<'a, C, NC, A> SchemaDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Immutable id of the Google Apps account - pub fn customer_id(mut self, new_value: &str) -> SchemaDeleteCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> SchemaDeleteCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -20055,7 +20051,7 @@ impl<'a, C, NC, A> SchemaDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Name or immutable Id of the schema - pub fn schema_key(mut self, new_value: &str) -> SchemaDeleteCall<'a, C, NC, A> { + pub fn schema_key(mut self, new_value: &str) -> SchemaDeleteCall<'a, C, A> { self._schema_key = new_value.to_string(); self } @@ -20066,7 +20062,7 @@ impl<'a, C, NC, A> SchemaDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SchemaDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SchemaDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -20087,7 +20083,7 @@ impl<'a, C, NC, A> SchemaDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SchemaDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SchemaDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -20104,7 +20100,7 @@ impl<'a, C, NC, A> SchemaDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SchemaDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SchemaDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -20148,10 +20144,10 @@ impl<'a, C, NC, A> SchemaDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct SchemaUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SchemaUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Directory, + hub: &'a Directory, _request: Schema, _customer_id: String, _schema_key: String, @@ -20160,9 +20156,9 @@ pub struct SchemaUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SchemaUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SchemaUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> SchemaUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SchemaUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -20302,7 +20298,7 @@ impl<'a, C, NC, A> SchemaUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Schema) -> SchemaUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Schema) -> SchemaUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -20312,7 +20308,7 @@ impl<'a, C, NC, A> SchemaUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Immutable id of the Google Apps account - pub fn customer_id(mut self, new_value: &str) -> SchemaUpdateCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> SchemaUpdateCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -20322,7 +20318,7 @@ impl<'a, C, NC, A> SchemaUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Name or immutable Id of the schema. - pub fn schema_key(mut self, new_value: &str) -> SchemaUpdateCall<'a, C, NC, A> { + pub fn schema_key(mut self, new_value: &str) -> SchemaUpdateCall<'a, C, A> { self._schema_key = new_value.to_string(); self } @@ -20333,7 +20329,7 @@ impl<'a, C, NC, A> SchemaUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SchemaUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SchemaUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -20354,7 +20350,7 @@ impl<'a, C, NC, A> SchemaUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SchemaUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SchemaUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -20371,7 +20367,7 @@ impl<'a, C, NC, A> SchemaUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SchemaUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SchemaUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/admin1_reports/Cargo.toml b/gen/admin1_reports/Cargo.toml index bf3c0d04b3e..f855bb54933 100644 --- a/gen/admin1_reports/Cargo.toml +++ b/gen/admin1_reports/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-admin1_reports" -version = "0.1.4+20150115" +version = "0.1.5+20150115" authors = ["Sebastian Thiel "] description = "A complete library to interact with reports (protocol reports_v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/admin1_reports" homepage = "https://developers.google.com/admin-sdk/reports/" -documentation = "http://byron.github.io/google-apis-rs/google-admin1_reports" +documentation = "http://byron.github.io/google-apis-rs/google_admin1_reports" license = "MIT" keywords = ["admin", "google", "protocol", "web", "api"] diff --git a/gen/admin1_reports/README.md b/gen/admin1_reports/README.md index e32d0ded351..b4f752530b9 100644 --- a/gen/admin1_reports/README.md +++ b/gen/admin1_reports/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-admin1_reports` library allows access to all features of the *Google reports* service. -This documentation was generated from *reports* crate version *0.1.4+20150115*, where *20150115* is the exact revision of the *admin:reports_v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *reports* crate version *0.1.5+20150115*, where *20150115* is the exact revision of the *admin:reports_v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *reports* *v1_reports* API can be found at the [official documentation site](https://developers.google.com/admin-sdk/reports/). diff --git a/gen/admin1_reports/src/cmn.rs b/gen/admin1_reports/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/admin1_reports/src/cmn.rs +++ b/gen/admin1_reports/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/admin1_reports/src/lib.rs b/gen/admin1_reports/src/lib.rs index 0a4b37e716b..4b4de92ba36 100644 --- a/gen/admin1_reports/src/lib.rs +++ b/gen/admin1_reports/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *reports* crate version *0.1.4+20150115*, where *20150115* is the exact revision of the *admin:reports_v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *reports* crate version *0.1.5+20150115*, where *20150115* is the exact revision of the *admin:reports_v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *reports* *v1_reports* API can be found at the //! [official documentation site](https://developers.google.com/admin-sdk/reports/). @@ -214,7 +214,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -323,43 +322,40 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Reports { +pub struct Reports { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Reports {} +impl<'a, C, A> Hub for Reports {} -impl<'a, C, NC, A> Reports - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Reports + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Reports { + pub fn new(client: C, authenticator: A) -> Reports { Reports { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn activities(&'a self) -> ActivityMethods<'a, C, NC, A> { + pub fn activities(&'a self) -> ActivityMethods<'a, C, A> { ActivityMethods { hub: &self } } - pub fn channels(&'a self) -> ChannelMethods<'a, C, NC, A> { + pub fn channels(&'a self) -> ChannelMethods<'a, C, A> { ChannelMethods { hub: &self } } - pub fn customer_usage_reports(&'a self) -> CustomerUsageReportMethods<'a, C, NC, A> { + pub fn customer_usage_reports(&'a self) -> CustomerUsageReportMethods<'a, C, A> { CustomerUsageReportMethods { hub: &self } } - pub fn user_usage_report(&'a self) -> UserUsageReportMethods<'a, C, NC, A> { + pub fn user_usage_report(&'a self) -> UserUsageReportMethods<'a, C, A> { UserUsageReportMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -729,15 +725,15 @@ impl ResponseResult for Channel {} /// let rb = hub.channels(); /// # } /// ``` -pub struct ChannelMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChannelMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reports, + hub: &'a Reports, } -impl<'a, C, NC, A> MethodsBuilder for ChannelMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ChannelMethods<'a, C, A> {} -impl<'a, C, NC, A> ChannelMethods<'a, C, NC, A> { +impl<'a, C, A> ChannelMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -746,7 +742,7 @@ impl<'a, C, NC, A> ChannelMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn stop(&self, request: &Channel) -> ChannelStopCall<'a, C, NC, A> { + pub fn stop(&self, request: &Channel) -> ChannelStopCall<'a, C, A> { ChannelStopCall { hub: self.hub, _request: request.clone(), @@ -787,15 +783,15 @@ impl<'a, C, NC, A> ChannelMethods<'a, C, NC, A> { /// let rb = hub.activities(); /// # } /// ``` -pub struct ActivityMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ActivityMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reports, + hub: &'a Reports, } -impl<'a, C, NC, A> MethodsBuilder for ActivityMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ActivityMethods<'a, C, A> {} -impl<'a, C, NC, A> ActivityMethods<'a, C, NC, A> { +impl<'a, C, A> ActivityMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -806,7 +802,7 @@ impl<'a, C, NC, A> ActivityMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `userKey` - Represents the profile id or the user email for which the data should be filtered. When 'all' is specified as the userKey, it returns usageReports for all users. /// * `applicationName` - Application name for which the events are to be retrieved. - pub fn watch(&self, request: &Channel, user_key: &str, application_name: &str) -> ActivityWatchCall<'a, C, NC, A> { + pub fn watch(&self, request: &Channel, user_key: &str, application_name: &str) -> ActivityWatchCall<'a, C, A> { ActivityWatchCall { hub: self.hub, _request: request.clone(), @@ -834,7 +830,7 @@ impl<'a, C, NC, A> ActivityMethods<'a, C, NC, A> { /// /// * `userKey` - Represents the profile id or the user email for which the data should be filtered. When 'all' is specified as the userKey, it returns usageReports for all users. /// * `applicationName` - Application name for which the events are to be retrieved. - pub fn list(&self, user_key: &str, application_name: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn list(&self, user_key: &str, application_name: &str) -> ActivityListCall<'a, C, A> { ActivityListCall { hub: self.hub, _user_key: user_key.to_string(), @@ -884,15 +880,15 @@ impl<'a, C, NC, A> ActivityMethods<'a, C, NC, A> { /// let rb = hub.customer_usage_reports(); /// # } /// ``` -pub struct CustomerUsageReportMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CustomerUsageReportMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reports, + hub: &'a Reports, } -impl<'a, C, NC, A> MethodsBuilder for CustomerUsageReportMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CustomerUsageReportMethods<'a, C, A> {} -impl<'a, C, NC, A> CustomerUsageReportMethods<'a, C, NC, A> { +impl<'a, C, A> CustomerUsageReportMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -901,7 +897,7 @@ impl<'a, C, NC, A> CustomerUsageReportMethods<'a, C, NC, A> { /// # Arguments /// /// * `date` - Represents the date in yyyy-mm-dd format for which the data is to be fetched. - pub fn get(&self, date: &str) -> CustomerUsageReportGetCall<'a, C, NC, A> { + pub fn get(&self, date: &str) -> CustomerUsageReportGetCall<'a, C, A> { CustomerUsageReportGetCall { hub: self.hub, _date: date.to_string(), @@ -945,15 +941,15 @@ impl<'a, C, NC, A> CustomerUsageReportMethods<'a, C, NC, A> { /// let rb = hub.user_usage_report(); /// # } /// ``` -pub struct UserUsageReportMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserUsageReportMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reports, + hub: &'a Reports, } -impl<'a, C, NC, A> MethodsBuilder for UserUsageReportMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for UserUsageReportMethods<'a, C, A> {} -impl<'a, C, NC, A> UserUsageReportMethods<'a, C, NC, A> { +impl<'a, C, A> UserUsageReportMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -963,7 +959,7 @@ impl<'a, C, NC, A> UserUsageReportMethods<'a, C, NC, A> { /// /// * `userKey` - Represents the profile id or the user email for which the data should be filtered. /// * `date` - Represents the date in yyyy-mm-dd format for which the data is to be fetched. - pub fn get(&self, user_key: &str, date: &str) -> UserUsageReportGetCall<'a, C, NC, A> { + pub fn get(&self, user_key: &str, date: &str) -> UserUsageReportGetCall<'a, C, A> { UserUsageReportGetCall { hub: self.hub, _user_key: user_key.to_string(), @@ -1024,19 +1020,19 @@ impl<'a, C, NC, A> UserUsageReportMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct ChannelStopCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChannelStopCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reports, + hub: &'a Reports, _request: Channel, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChannelStopCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChannelStopCall<'a, C, A> {} -impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChannelStopCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1139,7 +1135,7 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Channel) -> ChannelStopCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Channel) -> ChannelStopCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1150,7 +1146,7 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelStopCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelStopCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1171,7 +1167,7 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChannelStopCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChannelStopCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1188,7 +1184,7 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChannelStopCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChannelStopCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1240,10 +1236,10 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct ActivityWatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ActivityWatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reports, + hub: &'a Reports, _request: Channel, _user_key: String, _application_name: String, @@ -1260,9 +1256,9 @@ pub struct ActivityWatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ActivityWatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ActivityWatchCall<'a, C, A> {} -impl<'a, C, NC, A> ActivityWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ActivityWatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1426,7 +1422,7 @@ impl<'a, C, NC, A> ActivityWatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Channel) -> ActivityWatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Channel) -> ActivityWatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1436,7 +1432,7 @@ impl<'a, C, NC, A> ActivityWatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Represents the profile id or the user email for which the data should be filtered. When 'all' is specified as the userKey, it returns usageReports for all users. - pub fn user_key(mut self, new_value: &str) -> ActivityWatchCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> ActivityWatchCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -1446,7 +1442,7 @@ impl<'a, C, NC, A> ActivityWatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Application name for which the events are to be retrieved. - pub fn application_name(mut self, new_value: &str) -> ActivityWatchCall<'a, C, NC, A> { + pub fn application_name(mut self, new_value: &str) -> ActivityWatchCall<'a, C, A> { self._application_name = new_value.to_string(); self } @@ -1454,7 +1450,7 @@ impl<'a, C, NC, A> ActivityWatchCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Return events which occured at or after this time. - pub fn start_time(mut self, new_value: &str) -> ActivityWatchCall<'a, C, NC, A> { + pub fn start_time(mut self, new_value: &str) -> ActivityWatchCall<'a, C, A> { self._start_time = Some(new_value.to_string()); self } @@ -1462,7 +1458,7 @@ impl<'a, C, NC, A> ActivityWatchCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Token to specify next page. - pub fn page_token(mut self, new_value: &str) -> ActivityWatchCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ActivityWatchCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -1470,7 +1466,7 @@ impl<'a, C, NC, A> ActivityWatchCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Number of activity records to be shown in each page. - pub fn max_results(mut self, new_value: i32) -> ActivityWatchCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ActivityWatchCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -1478,7 +1474,7 @@ impl<'a, C, NC, A> ActivityWatchCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Event parameters in the form [parameter1 name][operator][parameter1 value],[parameter2 name][operator][parameter2 value],... - pub fn filters(mut self, new_value: &str) -> ActivityWatchCall<'a, C, NC, A> { + pub fn filters(mut self, new_value: &str) -> ActivityWatchCall<'a, C, A> { self._filters = Some(new_value.to_string()); self } @@ -1486,7 +1482,7 @@ impl<'a, C, NC, A> ActivityWatchCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Name of the event being queried. - pub fn event_name(mut self, new_value: &str) -> ActivityWatchCall<'a, C, NC, A> { + pub fn event_name(mut self, new_value: &str) -> ActivityWatchCall<'a, C, A> { self._event_name = Some(new_value.to_string()); self } @@ -1494,7 +1490,7 @@ impl<'a, C, NC, A> ActivityWatchCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Return events which occured at or before this time. - pub fn end_time(mut self, new_value: &str) -> ActivityWatchCall<'a, C, NC, A> { + pub fn end_time(mut self, new_value: &str) -> ActivityWatchCall<'a, C, A> { self._end_time = Some(new_value.to_string()); self } @@ -1502,7 +1498,7 @@ impl<'a, C, NC, A> ActivityWatchCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Represents the customer for which the data is to be fetched. - pub fn customer_id(mut self, new_value: &str) -> ActivityWatchCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> ActivityWatchCall<'a, C, A> { self._customer_id = Some(new_value.to_string()); self } @@ -1510,7 +1506,7 @@ impl<'a, C, NC, A> ActivityWatchCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// IP Address of host where the event was performed. Supports both IPv4 and IPv6 addresses. - pub fn actor_ip_address(mut self, new_value: &str) -> ActivityWatchCall<'a, C, NC, A> { + pub fn actor_ip_address(mut self, new_value: &str) -> ActivityWatchCall<'a, C, A> { self._actor_ip_address = Some(new_value.to_string()); self } @@ -1521,7 +1517,7 @@ impl<'a, C, NC, A> ActivityWatchCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivityWatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivityWatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1542,7 +1538,7 @@ impl<'a, C, NC, A> ActivityWatchCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ActivityWatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ActivityWatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1559,7 +1555,7 @@ impl<'a, C, NC, A> ActivityWatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ActivityWatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ActivityWatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1605,10 +1601,10 @@ impl<'a, C, NC, A> ActivityWatchCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct ActivityListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ActivityListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reports, + hub: &'a Reports, _user_key: String, _application_name: String, _start_time: Option, @@ -1624,9 +1620,9 @@ pub struct ActivityListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ActivityListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ActivityListCall<'a, C, A> {} -impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ActivityListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1783,7 +1779,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Represents the profile id or the user email for which the data should be filtered. When 'all' is specified as the userKey, it returns usageReports for all users. - pub fn user_key(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -1793,7 +1789,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Application name for which the events are to be retrieved. - pub fn application_name(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn application_name(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._application_name = new_value.to_string(); self } @@ -1801,7 +1797,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Return events which occured at or after this time. - pub fn start_time(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn start_time(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._start_time = Some(new_value.to_string()); self } @@ -1809,7 +1805,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Token to specify next page. - pub fn page_token(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -1817,7 +1813,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Number of activity records to be shown in each page. - pub fn max_results(mut self, new_value: i32) -> ActivityListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ActivityListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -1825,7 +1821,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Event parameters in the form [parameter1 name][operator][parameter1 value],[parameter2 name][operator][parameter2 value],... - pub fn filters(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn filters(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._filters = Some(new_value.to_string()); self } @@ -1833,7 +1829,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Name of the event being queried. - pub fn event_name(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn event_name(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._event_name = Some(new_value.to_string()); self } @@ -1841,7 +1837,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Return events which occured at or before this time. - pub fn end_time(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn end_time(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._end_time = Some(new_value.to_string()); self } @@ -1849,7 +1845,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Represents the customer for which the data is to be fetched. - pub fn customer_id(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._customer_id = Some(new_value.to_string()); self } @@ -1857,7 +1853,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// IP Address of host where the event was performed. Supports both IPv4 and IPv6 addresses. - pub fn actor_ip_address(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn actor_ip_address(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._actor_ip_address = Some(new_value.to_string()); self } @@ -1868,7 +1864,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivityListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivityListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1889,7 +1885,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ActivityListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ActivityListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1906,7 +1902,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ActivityListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ActivityListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1947,10 +1943,10 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct CustomerUsageReportGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CustomerUsageReportGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reports, + hub: &'a Reports, _date: String, _parameters: Option, _page_token: Option, @@ -1960,9 +1956,9 @@ pub struct CustomerUsageReportGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CustomerUsageReportGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CustomerUsageReportGetCall<'a, C, A> {} -impl<'a, C, NC, A> CustomerUsageReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CustomerUsageReportGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2103,7 +2099,7 @@ impl<'a, C, NC, A> CustomerUsageReportGetCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Represents the date in yyyy-mm-dd format for which the data is to be fetched. - pub fn date(mut self, new_value: &str) -> CustomerUsageReportGetCall<'a, C, NC, A> { + pub fn date(mut self, new_value: &str) -> CustomerUsageReportGetCall<'a, C, A> { self._date = new_value.to_string(); self } @@ -2111,7 +2107,7 @@ impl<'a, C, NC, A> CustomerUsageReportGetCall<'a, C, NC, A> where NC: hyper::net /// /// /// Represents the application name, parameter name pairs to fetch in csv as app_name1:param_name1, app_name2:param_name2. - pub fn parameters(mut self, new_value: &str) -> CustomerUsageReportGetCall<'a, C, NC, A> { + pub fn parameters(mut self, new_value: &str) -> CustomerUsageReportGetCall<'a, C, A> { self._parameters = Some(new_value.to_string()); self } @@ -2119,7 +2115,7 @@ impl<'a, C, NC, A> CustomerUsageReportGetCall<'a, C, NC, A> where NC: hyper::net /// /// /// Token to specify next page. - pub fn page_token(mut self, new_value: &str) -> CustomerUsageReportGetCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> CustomerUsageReportGetCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2127,7 +2123,7 @@ impl<'a, C, NC, A> CustomerUsageReportGetCall<'a, C, NC, A> where NC: hyper::net /// /// /// Represents the customer for which the data is to be fetched. - pub fn customer_id(mut self, new_value: &str) -> CustomerUsageReportGetCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> CustomerUsageReportGetCall<'a, C, A> { self._customer_id = Some(new_value.to_string()); self } @@ -2138,7 +2134,7 @@ impl<'a, C, NC, A> CustomerUsageReportGetCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomerUsageReportGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomerUsageReportGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2159,7 +2155,7 @@ impl<'a, C, NC, A> CustomerUsageReportGetCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CustomerUsageReportGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CustomerUsageReportGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2176,7 +2172,7 @@ impl<'a, C, NC, A> CustomerUsageReportGetCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CustomerUsageReportGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CustomerUsageReportGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2219,10 +2215,10 @@ impl<'a, C, NC, A> CustomerUsageReportGetCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct UserUsageReportGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserUsageReportGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reports, + hub: &'a Reports, _user_key: String, _date: String, _parameters: Option, @@ -2235,9 +2231,9 @@ pub struct UserUsageReportGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserUsageReportGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserUsageReportGetCall<'a, C, A> {} -impl<'a, C, NC, A> UserUsageReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserUsageReportGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2385,7 +2381,7 @@ impl<'a, C, NC, A> UserUsageReportGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Represents the profile id or the user email for which the data should be filtered. - pub fn user_key(mut self, new_value: &str) -> UserUsageReportGetCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> UserUsageReportGetCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -2395,7 +2391,7 @@ impl<'a, C, NC, A> UserUsageReportGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Represents the date in yyyy-mm-dd format for which the data is to be fetched. - pub fn date(mut self, new_value: &str) -> UserUsageReportGetCall<'a, C, NC, A> { + pub fn date(mut self, new_value: &str) -> UserUsageReportGetCall<'a, C, A> { self._date = new_value.to_string(); self } @@ -2403,7 +2399,7 @@ impl<'a, C, NC, A> UserUsageReportGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Represents the application name, parameter name pairs to fetch in csv as app_name1:param_name1, app_name2:param_name2. - pub fn parameters(mut self, new_value: &str) -> UserUsageReportGetCall<'a, C, NC, A> { + pub fn parameters(mut self, new_value: &str) -> UserUsageReportGetCall<'a, C, A> { self._parameters = Some(new_value.to_string()); self } @@ -2411,7 +2407,7 @@ impl<'a, C, NC, A> UserUsageReportGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Token to specify next page. - pub fn page_token(mut self, new_value: &str) -> UserUsageReportGetCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> UserUsageReportGetCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2419,7 +2415,7 @@ impl<'a, C, NC, A> UserUsageReportGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Maximum number of results to return. Maximum allowed is 1000 - pub fn max_results(mut self, new_value: u32) -> UserUsageReportGetCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> UserUsageReportGetCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2427,7 +2423,7 @@ impl<'a, C, NC, A> UserUsageReportGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Represents the set of filters including parameter operator value. - pub fn filters(mut self, new_value: &str) -> UserUsageReportGetCall<'a, C, NC, A> { + pub fn filters(mut self, new_value: &str) -> UserUsageReportGetCall<'a, C, A> { self._filters = Some(new_value.to_string()); self } @@ -2435,7 +2431,7 @@ impl<'a, C, NC, A> UserUsageReportGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Represents the customer for which the data is to be fetched. - pub fn customer_id(mut self, new_value: &str) -> UserUsageReportGetCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> UserUsageReportGetCall<'a, C, A> { self._customer_id = Some(new_value.to_string()); self } @@ -2446,7 +2442,7 @@ impl<'a, C, NC, A> UserUsageReportGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserUsageReportGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserUsageReportGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2467,7 +2463,7 @@ impl<'a, C, NC, A> UserUsageReportGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserUsageReportGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserUsageReportGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2484,7 +2480,7 @@ impl<'a, C, NC, A> UserUsageReportGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserUsageReportGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserUsageReportGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/admin2_email_migration/Cargo.toml b/gen/admin2_email_migration/Cargo.toml index 85607524154..152ba41e219 100644 --- a/gen/admin2_email_migration/Cargo.toml +++ b/gen/admin2_email_migration/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-admin2_email_migration" -version = "0.1.4+20150303" +version = "0.1.5+20150303" authors = ["Sebastian Thiel "] description = "A complete library to interact with admin (protocol email_migration_v2)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/admin2_email_migration" homepage = "https://developers.google.com/admin-sdk/email-migration/v2/" -documentation = "http://byron.github.io/google-apis-rs/google-admin2_email_migration" +documentation = "http://byron.github.io/google-apis-rs/google_admin2_email_migration" license = "MIT" keywords = ["admin", "google", "protocol", "web", "api"] diff --git a/gen/admin2_email_migration/README.md b/gen/admin2_email_migration/README.md index d14b848da54..2438edf29c0 100644 --- a/gen/admin2_email_migration/README.md +++ b/gen/admin2_email_migration/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-admin2_email_migration` library allows access to all features of the *Google admin* service. -This documentation was generated from *admin* crate version *0.1.4+20150303*, where *20150303* is the exact revision of the *admin:email_migration_v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *admin* crate version *0.1.5+20150303*, where *20150303* is the exact revision of the *admin:email_migration_v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *admin* *v2_email_migration* API can be found at the [official documentation site](https://developers.google.com/admin-sdk/email-migration/v2/). diff --git a/gen/admin2_email_migration/src/cmn.rs b/gen/admin2_email_migration/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/admin2_email_migration/src/cmn.rs +++ b/gen/admin2_email_migration/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/admin2_email_migration/src/lib.rs b/gen/admin2_email_migration/src/lib.rs index 0543fefeed8..29ccf862f82 100644 --- a/gen/admin2_email_migration/src/lib.rs +++ b/gen/admin2_email_migration/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *admin* crate version *0.1.4+20150303*, where *20150303* is the exact revision of the *admin:email_migration_v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *admin* crate version *0.1.5+20150303*, where *20150303* is the exact revision of the *admin:email_migration_v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *admin* *v2_email_migration* API can be found at the //! [official documentation site](https://developers.google.com/admin-sdk/email-migration/v2/). @@ -199,7 +199,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -297,34 +296,31 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Admin { +pub struct Admin { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Admin {} +impl<'a, C, A> Hub for Admin {} -impl<'a, C, NC, A> Admin - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Admin + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Admin { + pub fn new(client: C, authenticator: A) -> Admin { Admin { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn mail(&'a self) -> MailMethods<'a, C, NC, A> { + pub fn mail(&'a self) -> MailMethods<'a, C, A> { MailMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -412,15 +408,15 @@ impl RequestValue for MailItem {} /// let rb = hub.mail(); /// # } /// ``` -pub struct MailMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MailMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Admin, + hub: &'a Admin, } -impl<'a, C, NC, A> MethodsBuilder for MailMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for MailMethods<'a, C, A> {} -impl<'a, C, NC, A> MailMethods<'a, C, NC, A> { +impl<'a, C, A> MailMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -430,7 +426,7 @@ impl<'a, C, NC, A> MailMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `userKey` - The email or immutable id of the user - pub fn insert(&self, request: &MailItem, user_key: &str) -> MailInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &MailItem, user_key: &str) -> MailInsertCall<'a, C, A> { MailInsertCall { hub: self.hub, _request: request.clone(), @@ -487,10 +483,10 @@ impl<'a, C, NC, A> MailMethods<'a, C, NC, A> { /// .upload(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct MailInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MailInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Admin, + hub: &'a Admin, _request: MailItem, _user_key: String, _delegate: Option<&'a mut Delegate>, @@ -498,9 +494,9 @@ pub struct MailInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MailInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MailInsertCall<'a, C, A> {} -impl<'a, C, NC, A> MailInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MailInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -742,7 +738,7 @@ impl<'a, C, NC, A> MailInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &MailItem) -> MailInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &MailItem) -> MailInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -752,7 +748,7 @@ impl<'a, C, NC, A> MailInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The email or immutable id of the user - pub fn user_key(mut self, new_value: &str) -> MailInsertCall<'a, C, NC, A> { + pub fn user_key(mut self, new_value: &str) -> MailInsertCall<'a, C, A> { self._user_key = new_value.to_string(); self } @@ -763,7 +759,7 @@ impl<'a, C, NC, A> MailInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MailInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MailInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -784,7 +780,7 @@ impl<'a, C, NC, A> MailInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MailInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MailInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -801,7 +797,7 @@ impl<'a, C, NC, A> MailInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MailInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MailInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/adsense1d4/Cargo.toml b/gen/adsense1d4/Cargo.toml index 73e707f168d..1f5ba0cb366 100644 --- a/gen/adsense1d4/Cargo.toml +++ b/gen/adsense1d4/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-adsense1d4" -version = "0.1.4+20150326" +version = "0.1.5+20150326" authors = ["Sebastian Thiel "] description = "A complete library to interact with AdSense (protocol v1.4)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/adsense1d4" homepage = "https://developers.google.com/adsense/management/" -documentation = "http://byron.github.io/google-apis-rs/google-adsense1d4" +documentation = "http://byron.github.io/google-apis-rs/google_adsense1d4" license = "MIT" keywords = ["adsense", "google", "protocol", "web", "api"] diff --git a/gen/adsense1d4/README.md b/gen/adsense1d4/README.md index b43a2b01a84..da9e4c14b8d 100644 --- a/gen/adsense1d4/README.md +++ b/gen/adsense1d4/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-adsense1d4` library allows access to all features of the *Google AdSense* service. -This documentation was generated from *AdSense* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *adsense:v1.4* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *AdSense* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *adsense:v1.4* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *AdSense* *v1d4* API can be found at the [official documentation site](https://developers.google.com/adsense/management/). diff --git a/gen/adsense1d4/src/cmn.rs b/gen/adsense1d4/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/adsense1d4/src/cmn.rs +++ b/gen/adsense1d4/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/adsense1d4/src/lib.rs b/gen/adsense1d4/src/lib.rs index 85d0363b126..6434c0e7b4b 100644 --- a/gen/adsense1d4/src/lib.rs +++ b/gen/adsense1d4/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *AdSense* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *adsense:v1.4* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *AdSense* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *adsense:v1.4* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *AdSense* *v1d4* API can be found at the //! [official documentation site](https://developers.google.com/adsense/management/). @@ -238,7 +238,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -342,61 +341,58 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct AdSense { +pub struct AdSense { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for AdSense {} +impl<'a, C, A> Hub for AdSense {} -impl<'a, C, NC, A> AdSense - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdSense + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> AdSense { + pub fn new(client: C, authenticator: A) -> AdSense { AdSense { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn accounts(&'a self) -> AccountMethods<'a, C, NC, A> { + pub fn accounts(&'a self) -> AccountMethods<'a, C, A> { AccountMethods { hub: &self } } - pub fn adclients(&'a self) -> AdclientMethods<'a, C, NC, A> { + pub fn adclients(&'a self) -> AdclientMethods<'a, C, A> { AdclientMethods { hub: &self } } - pub fn adunits(&'a self) -> AdunitMethods<'a, C, NC, A> { + pub fn adunits(&'a self) -> AdunitMethods<'a, C, A> { AdunitMethods { hub: &self } } - pub fn alerts(&'a self) -> AlertMethods<'a, C, NC, A> { + pub fn alerts(&'a self) -> AlertMethods<'a, C, A> { AlertMethods { hub: &self } } - pub fn customchannels(&'a self) -> CustomchannelMethods<'a, C, NC, A> { + pub fn customchannels(&'a self) -> CustomchannelMethods<'a, C, A> { CustomchannelMethods { hub: &self } } - pub fn metadata(&'a self) -> MetadataMethods<'a, C, NC, A> { + pub fn metadata(&'a self) -> MetadataMethods<'a, C, A> { MetadataMethods { hub: &self } } - pub fn payments(&'a self) -> PaymentMethods<'a, C, NC, A> { + pub fn payments(&'a self) -> PaymentMethods<'a, C, A> { PaymentMethods { hub: &self } } - pub fn reports(&'a self) -> ReportMethods<'a, C, NC, A> { + pub fn reports(&'a self) -> ReportMethods<'a, C, A> { ReportMethods { hub: &self } } - pub fn savedadstyles(&'a self) -> SavedadstyleMethods<'a, C, NC, A> { + pub fn savedadstyles(&'a self) -> SavedadstyleMethods<'a, C, A> { SavedadstyleMethods { hub: &self } } - pub fn urlchannels(&'a self) -> UrlchannelMethods<'a, C, NC, A> { + pub fn urlchannels(&'a self) -> UrlchannelMethods<'a, C, A> { UrlchannelMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -1240,15 +1236,15 @@ impl Resource for Payment {} /// let rb = hub.urlchannels(); /// # } /// ``` -pub struct UrlchannelMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlchannelMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, } -impl<'a, C, NC, A> MethodsBuilder for UrlchannelMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for UrlchannelMethods<'a, C, A> {} -impl<'a, C, NC, A> UrlchannelMethods<'a, C, NC, A> { +impl<'a, C, A> UrlchannelMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1257,7 +1253,7 @@ impl<'a, C, NC, A> UrlchannelMethods<'a, C, NC, A> { /// # Arguments /// /// * `adClientId` - Ad client for which to list URL channels. - pub fn list(&self, ad_client_id: &str) -> UrlchannelListCall<'a, C, NC, A> { + pub fn list(&self, ad_client_id: &str) -> UrlchannelListCall<'a, C, A> { UrlchannelListCall { hub: self.hub, _ad_client_id: ad_client_id.to_string(), @@ -1300,15 +1296,15 @@ impl<'a, C, NC, A> UrlchannelMethods<'a, C, NC, A> { /// let rb = hub.adunits(); /// # } /// ``` -pub struct AdunitMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdunitMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, } -impl<'a, C, NC, A> MethodsBuilder for AdunitMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AdunitMethods<'a, C, A> {} -impl<'a, C, NC, A> AdunitMethods<'a, C, NC, A> { +impl<'a, C, A> AdunitMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1318,7 +1314,7 @@ impl<'a, C, NC, A> AdunitMethods<'a, C, NC, A> { /// /// * `adClientId` - Ad client which contains the ad unit. /// * `adUnitId` - Ad unit for which to list custom channels. - pub fn customchannels_list(&self, ad_client_id: &str, ad_unit_id: &str) -> AdunitCustomchannelListCall<'a, C, NC, A> { + pub fn customchannels_list(&self, ad_client_id: &str, ad_unit_id: &str) -> AdunitCustomchannelListCall<'a, C, A> { AdunitCustomchannelListCall { hub: self.hub, _ad_client_id: ad_client_id.to_string(), @@ -1339,7 +1335,7 @@ impl<'a, C, NC, A> AdunitMethods<'a, C, NC, A> { /// /// * `adClientId` - Ad client for which to get the ad unit. /// * `adUnitId` - Ad unit to retrieve. - pub fn get(&self, ad_client_id: &str, ad_unit_id: &str) -> AdunitGetCall<'a, C, NC, A> { + pub fn get(&self, ad_client_id: &str, ad_unit_id: &str) -> AdunitGetCall<'a, C, A> { AdunitGetCall { hub: self.hub, _ad_client_id: ad_client_id.to_string(), @@ -1357,7 +1353,7 @@ impl<'a, C, NC, A> AdunitMethods<'a, C, NC, A> { /// # Arguments /// /// * `adClientId` - Ad client for which to list ad units. - pub fn list(&self, ad_client_id: &str) -> AdunitListCall<'a, C, NC, A> { + pub fn list(&self, ad_client_id: &str) -> AdunitListCall<'a, C, A> { AdunitListCall { hub: self.hub, _ad_client_id: ad_client_id.to_string(), @@ -1378,7 +1374,7 @@ impl<'a, C, NC, A> AdunitMethods<'a, C, NC, A> { /// /// * `adClientId` - Ad client with contains the ad unit. /// * `adUnitId` - Ad unit to get the code for. - pub fn get_ad_code(&self, ad_client_id: &str, ad_unit_id: &str) -> AdunitGetAdCodeCall<'a, C, NC, A> { + pub fn get_ad_code(&self, ad_client_id: &str, ad_unit_id: &str) -> AdunitGetAdCodeCall<'a, C, A> { AdunitGetAdCodeCall { hub: self.hub, _ad_client_id: ad_client_id.to_string(), @@ -1420,20 +1416,20 @@ impl<'a, C, NC, A> AdunitMethods<'a, C, NC, A> { /// let rb = hub.adclients(); /// # } /// ``` -pub struct AdclientMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdclientMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, } -impl<'a, C, NC, A> MethodsBuilder for AdclientMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AdclientMethods<'a, C, A> {} -impl<'a, C, NC, A> AdclientMethods<'a, C, NC, A> { +impl<'a, C, A> AdclientMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// List all ad clients in this AdSense account. - pub fn list(&self) -> AdclientListCall<'a, C, NC, A> { + pub fn list(&self) -> AdclientListCall<'a, C, A> { AdclientListCall { hub: self.hub, _page_token: Default::default(), @@ -1475,15 +1471,15 @@ impl<'a, C, NC, A> AdclientMethods<'a, C, NC, A> { /// let rb = hub.alerts(); /// # } /// ``` -pub struct AlertMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AlertMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, } -impl<'a, C, NC, A> MethodsBuilder for AlertMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AlertMethods<'a, C, A> {} -impl<'a, C, NC, A> AlertMethods<'a, C, NC, A> { +impl<'a, C, A> AlertMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1492,7 +1488,7 @@ impl<'a, C, NC, A> AlertMethods<'a, C, NC, A> { /// # Arguments /// /// * `alertId` - Alert to delete. - pub fn delete(&self, alert_id: &str) -> AlertDeleteCall<'a, C, NC, A> { + pub fn delete(&self, alert_id: &str) -> AlertDeleteCall<'a, C, A> { AlertDeleteCall { hub: self.hub, _alert_id: alert_id.to_string(), @@ -1505,7 +1501,7 @@ impl<'a, C, NC, A> AlertMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// List the alerts for this AdSense account. - pub fn list(&self) -> AlertListCall<'a, C, NC, A> { + pub fn list(&self) -> AlertListCall<'a, C, A> { AlertListCall { hub: self.hub, _locale: Default::default(), @@ -1546,20 +1542,20 @@ impl<'a, C, NC, A> AlertMethods<'a, C, NC, A> { /// let rb = hub.savedadstyles(); /// # } /// ``` -pub struct SavedadstyleMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SavedadstyleMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, } -impl<'a, C, NC, A> MethodsBuilder for SavedadstyleMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for SavedadstyleMethods<'a, C, A> {} -impl<'a, C, NC, A> SavedadstyleMethods<'a, C, NC, A> { +impl<'a, C, A> SavedadstyleMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// List all saved ad styles in the user's account. - pub fn list(&self) -> SavedadstyleListCall<'a, C, NC, A> { + pub fn list(&self) -> SavedadstyleListCall<'a, C, A> { SavedadstyleListCall { hub: self.hub, _page_token: Default::default(), @@ -1577,7 +1573,7 @@ impl<'a, C, NC, A> SavedadstyleMethods<'a, C, NC, A> { /// # Arguments /// /// * `savedAdStyleId` - Saved ad style to retrieve. - pub fn get(&self, saved_ad_style_id: &str) -> SavedadstyleGetCall<'a, C, NC, A> { + pub fn get(&self, saved_ad_style_id: &str) -> SavedadstyleGetCall<'a, C, A> { SavedadstyleGetCall { hub: self.hub, _saved_ad_style_id: saved_ad_style_id.to_string(), @@ -1618,20 +1614,20 @@ impl<'a, C, NC, A> SavedadstyleMethods<'a, C, NC, A> { /// let rb = hub.reports(); /// # } /// ``` -pub struct ReportMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, } -impl<'a, C, NC, A> MethodsBuilder for ReportMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ReportMethods<'a, C, A> {} -impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { +impl<'a, C, A> ReportMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// List all saved reports in this AdSense account. - pub fn saved_list(&self) -> ReportSavedListCall<'a, C, NC, A> { + pub fn saved_list(&self) -> ReportSavedListCall<'a, C, A> { ReportSavedListCall { hub: self.hub, _page_token: Default::default(), @@ -1650,7 +1646,7 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// /// * `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 generate(&self, start_date: &str, end_date: &str) -> ReportGenerateCall<'a, C, NC, A> { + pub fn generate(&self, start_date: &str, end_date: &str) -> ReportGenerateCall<'a, C, A> { ReportGenerateCall { hub: self.hub, _start_date: start_date.to_string(), @@ -1678,7 +1674,7 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// # Arguments /// /// * `savedReportId` - The saved report to retrieve. - pub fn saved_generate(&self, saved_report_id: &str) -> ReportSavedGenerateCall<'a, C, NC, A> { + pub fn saved_generate(&self, saved_report_id: &str) -> ReportSavedGenerateCall<'a, C, A> { ReportSavedGenerateCall { hub: self.hub, _saved_report_id: saved_report_id.to_string(), @@ -1722,15 +1718,15 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// let rb = hub.accounts(); /// # } /// ``` -pub struct AccountMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, } -impl<'a, C, NC, A> MethodsBuilder for AccountMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AccountMethods<'a, C, A> {} -impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { +impl<'a, C, A> AccountMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1740,7 +1736,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `accountId` - Account which contains the ad unit. /// * `alertId` - Alert to delete. - pub fn alerts_delete(&self, account_id: &str, alert_id: &str) -> AccountAlertDeleteCall<'a, C, NC, A> { + pub fn alerts_delete(&self, account_id: &str, alert_id: &str) -> AccountAlertDeleteCall<'a, C, A> { AccountAlertDeleteCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1758,7 +1754,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `accountId` - Account for which to retrieve the alerts. - pub fn alerts_list(&self, account_id: &str) -> AccountAlertListCall<'a, C, NC, A> { + pub fn alerts_list(&self, account_id: &str) -> AccountAlertListCall<'a, C, A> { AccountAlertListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1777,7 +1773,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `accountId` - Account to which the saved reports belong. /// * `savedReportId` - The saved report to retrieve. - pub fn reports_saved_generate(&self, account_id: &str, saved_report_id: &str) -> AccountReportSavedGenerateCall<'a, C, NC, A> { + pub fn reports_saved_generate(&self, account_id: &str, saved_report_id: &str) -> AccountReportSavedGenerateCall<'a, C, A> { AccountReportSavedGenerateCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1794,7 +1790,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// List all accounts available to this AdSense account. - pub fn list(&self) -> AccountListCall<'a, C, NC, A> { + pub fn list(&self) -> AccountListCall<'a, C, A> { AccountListCall { hub: self.hub, _page_token: Default::default(), @@ -1812,7 +1808,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `accountId` - Account for which to retrieve the payments. - pub fn payments_list(&self, account_id: &str) -> AccountPaymentListCall<'a, C, NC, A> { + pub fn payments_list(&self, account_id: &str) -> AccountPaymentListCall<'a, C, A> { AccountPaymentListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1830,7 +1826,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `accountId` - Account for which to get the saved ad style. /// * `savedAdStyleId` - Saved ad style to retrieve. - pub fn savedadstyles_get(&self, account_id: &str, saved_ad_style_id: &str) -> AccountSavedadstyleGetCall<'a, C, NC, A> { + pub fn savedadstyles_get(&self, account_id: &str, saved_ad_style_id: &str) -> AccountSavedadstyleGetCall<'a, C, A> { AccountSavedadstyleGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1850,7 +1846,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - Account to which the ad client belongs. /// * `adClientId` - Ad client for which to get the ad unit. /// * `adUnitId` - Ad unit to retrieve. - pub fn adunits_get(&self, account_id: &str, ad_client_id: &str, ad_unit_id: &str) -> AccountAdunitGetCall<'a, C, NC, A> { + pub fn adunits_get(&self, account_id: &str, ad_client_id: &str, ad_unit_id: &str) -> AccountAdunitGetCall<'a, C, A> { AccountAdunitGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1871,7 +1867,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `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, C, NC, A> { + pub fn customchannels_get(&self, account_id: &str, ad_client_id: &str, custom_channel_id: &str) -> AccountCustomchannelGetCall<'a, C, A> { AccountCustomchannelGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1892,7 +1888,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - Account to which the ad client belongs. /// * `adClientId` - Ad client which contains the custom channel. /// * `customChannelId` - Custom channel for which to list ad units. - pub fn customchannels_adunits_list(&self, account_id: &str, ad_client_id: &str, custom_channel_id: &str) -> AccountCustomchannelAdunitListCall<'a, C, NC, A> { + pub fn customchannels_adunits_list(&self, account_id: &str, ad_client_id: &str, custom_channel_id: &str) -> AccountCustomchannelAdunitListCall<'a, C, A> { AccountCustomchannelAdunitListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1914,7 +1910,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `accountId` - Account to which the saved reports belong. - pub fn reports_saved_list(&self, account_id: &str) -> AccountReportSavedListCall<'a, C, NC, A> { + pub fn reports_saved_list(&self, account_id: &str) -> AccountReportSavedListCall<'a, C, A> { AccountReportSavedListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1934,7 +1930,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `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, C, NC, A> { + pub fn urlchannels_list(&self, account_id: &str, ad_client_id: &str) -> AccountUrlchannelListCall<'a, C, A> { AccountUrlchannelListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1955,7 +1951,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `accountId` - Account to which the ad client belongs. /// * `adClientId` - Ad client for which to list ad units. - pub fn adunits_list(&self, account_id: &str, ad_client_id: &str) -> AccountAdunitListCall<'a, C, NC, A> { + pub fn adunits_list(&self, account_id: &str, ad_client_id: &str) -> AccountAdunitListCall<'a, C, A> { AccountAdunitListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1978,7 +1974,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - Account upon which to 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, C, NC, A> { + pub fn reports_generate(&self, account_id: &str, start_date: &str, end_date: &str) -> AccountReportGenerateCall<'a, C, A> { AccountReportGenerateCall { hub: self.hub, _account_id: account_id.to_string(), @@ -2006,7 +2002,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `accountId` - Account for which to list ad clients. - pub fn adclients_list(&self, account_id: &str) -> AccountAdclientListCall<'a, C, NC, A> { + pub fn adclients_list(&self, account_id: &str) -> AccountAdclientListCall<'a, C, A> { AccountAdclientListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -2026,7 +2022,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `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, C, NC, A> { + pub fn customchannels_list(&self, account_id: &str, ad_client_id: &str) -> AccountCustomchannelListCall<'a, C, A> { AccountCustomchannelListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -2046,7 +2042,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `accountId` - Account for which to list saved ad styles. - pub fn savedadstyles_list(&self, account_id: &str) -> AccountSavedadstyleListCall<'a, C, NC, A> { + pub fn savedadstyles_list(&self, account_id: &str) -> AccountSavedadstyleListCall<'a, C, A> { AccountSavedadstyleListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -2067,7 +2063,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - Account which contains the ad client. /// * `adClientId` - Ad client with contains the ad unit. /// * `adUnitId` - Ad unit to get the code for. - pub fn adunits_get_ad_code(&self, account_id: &str, ad_client_id: &str, ad_unit_id: &str) -> AccountAdunitGetAdCodeCall<'a, C, NC, A> { + pub fn adunits_get_ad_code(&self, account_id: &str, ad_client_id: &str, ad_unit_id: &str) -> AccountAdunitGetAdCodeCall<'a, C, A> { AccountAdunitGetAdCodeCall { hub: self.hub, _account_id: account_id.to_string(), @@ -2088,7 +2084,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - Account to which the ad client belongs. /// * `adClientId` - Ad client which contains the ad unit. /// * `adUnitId` - Ad unit for which to list custom channels. - pub fn adunits_customchannels_list(&self, account_id: &str, ad_client_id: &str, ad_unit_id: &str) -> AccountAdunitCustomchannelListCall<'a, C, NC, A> { + pub fn adunits_customchannels_list(&self, account_id: &str, ad_client_id: &str, ad_unit_id: &str) -> AccountAdunitCustomchannelListCall<'a, C, A> { AccountAdunitCustomchannelListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -2109,7 +2105,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `accountId` - Account to get information about. - pub fn get(&self, account_id: &str) -> AccountGetCall<'a, C, NC, A> { + pub fn get(&self, account_id: &str) -> AccountGetCall<'a, C, A> { AccountGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -2151,20 +2147,20 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// let rb = hub.payments(); /// # } /// ``` -pub struct PaymentMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PaymentMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, } -impl<'a, C, NC, A> MethodsBuilder for PaymentMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PaymentMethods<'a, C, A> {} -impl<'a, C, NC, A> PaymentMethods<'a, C, NC, A> { +impl<'a, C, A> PaymentMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// List the payments for this AdSense account. - pub fn list(&self) -> PaymentListCall<'a, C, NC, A> { + pub fn list(&self) -> PaymentListCall<'a, C, A> { PaymentListCall { hub: self.hub, _delegate: Default::default(), @@ -2204,20 +2200,20 @@ impl<'a, C, NC, A> PaymentMethods<'a, C, NC, A> { /// let rb = hub.metadata(); /// # } /// ``` -pub struct MetadataMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MetadataMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, } -impl<'a, C, NC, A> MethodsBuilder for MetadataMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for MetadataMethods<'a, C, A> {} -impl<'a, C, NC, A> MetadataMethods<'a, C, NC, A> { +impl<'a, C, A> MetadataMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// List the metadata for the dimensions available to this AdSense account. - pub fn dimensions_list(&self) -> MetadataDimensionListCall<'a, C, NC, A> { + pub fn dimensions_list(&self) -> MetadataDimensionListCall<'a, C, A> { MetadataDimensionListCall { hub: self.hub, _delegate: Default::default(), @@ -2229,7 +2225,7 @@ impl<'a, C, NC, A> MetadataMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// List the metadata for the metrics available to this AdSense account. - pub fn metrics_list(&self) -> MetadataMetricListCall<'a, C, NC, A> { + pub fn metrics_list(&self) -> MetadataMetricListCall<'a, C, A> { MetadataMetricListCall { hub: self.hub, _delegate: Default::default(), @@ -2269,15 +2265,15 @@ impl<'a, C, NC, A> MetadataMethods<'a, C, NC, A> { /// let rb = hub.customchannels(); /// # } /// ``` -pub struct CustomchannelMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CustomchannelMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, } -impl<'a, C, NC, A> MethodsBuilder for CustomchannelMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CustomchannelMethods<'a, C, A> {} -impl<'a, C, NC, A> CustomchannelMethods<'a, C, NC, A> { +impl<'a, C, A> CustomchannelMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2287,7 +2283,7 @@ impl<'a, C, NC, A> CustomchannelMethods<'a, C, NC, A> { /// /// * `adClientId` - Ad client which contains the custom channel. /// * `customChannelId` - Custom channel to retrieve. - pub fn get(&self, ad_client_id: &str, custom_channel_id: &str) -> CustomchannelGetCall<'a, C, NC, A> { + pub fn get(&self, ad_client_id: &str, custom_channel_id: &str) -> CustomchannelGetCall<'a, C, A> { CustomchannelGetCall { hub: self.hub, _ad_client_id: ad_client_id.to_string(), @@ -2305,7 +2301,7 @@ impl<'a, C, NC, A> CustomchannelMethods<'a, C, NC, A> { /// # Arguments /// /// * `adClientId` - Ad client for which to list custom channels. - pub fn list(&self, ad_client_id: &str) -> CustomchannelListCall<'a, C, NC, A> { + pub fn list(&self, ad_client_id: &str) -> CustomchannelListCall<'a, C, A> { CustomchannelListCall { hub: self.hub, _ad_client_id: ad_client_id.to_string(), @@ -2325,7 +2321,7 @@ impl<'a, C, NC, A> CustomchannelMethods<'a, C, NC, A> { /// /// * `adClientId` - Ad client which contains the custom channel. /// * `customChannelId` - Custom channel for which to list ad units. - pub fn adunits_list(&self, ad_client_id: &str, custom_channel_id: &str) -> CustomchannelAdunitListCall<'a, C, NC, A> { + pub fn adunits_list(&self, ad_client_id: &str, custom_channel_id: &str) -> CustomchannelAdunitListCall<'a, C, A> { CustomchannelAdunitListCall { hub: self.hub, _ad_client_id: ad_client_id.to_string(), @@ -2380,10 +2376,10 @@ impl<'a, C, NC, A> CustomchannelMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct UrlchannelListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlchannelListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _ad_client_id: String, _page_token: Option, _max_results: Option, @@ -2392,9 +2388,9 @@ pub struct UrlchannelListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UrlchannelListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UrlchannelListCall<'a, C, A> {} -impl<'a, C, NC, A> UrlchannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UrlchannelListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2532,7 +2528,7 @@ impl<'a, C, NC, A> UrlchannelListCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Ad client for which to list URL channels. - pub fn ad_client_id(mut self, new_value: &str) -> UrlchannelListCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> UrlchannelListCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -2540,7 +2536,7 @@ impl<'a, C, NC, A> UrlchannelListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// A continuation token, used to page through URL channels. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> UrlchannelListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> UrlchannelListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2548,7 +2544,7 @@ impl<'a, C, NC, A> UrlchannelListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The maximum number of URL channels to include in the response, used for paging. - pub fn max_results(mut self, new_value: i32) -> UrlchannelListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> UrlchannelListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2559,7 +2555,7 @@ impl<'a, C, NC, A> UrlchannelListCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlchannelListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlchannelListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2580,7 +2576,7 @@ impl<'a, C, NC, A> UrlchannelListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UrlchannelListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UrlchannelListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2597,7 +2593,7 @@ impl<'a, C, NC, A> UrlchannelListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UrlchannelListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UrlchannelListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2637,10 +2633,10 @@ impl<'a, C, NC, A> UrlchannelListCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct AdunitCustomchannelListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdunitCustomchannelListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _ad_client_id: String, _ad_unit_id: String, _page_token: Option, @@ -2650,9 +2646,9 @@ pub struct AdunitCustomchannelListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AdunitCustomchannelListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdunitCustomchannelListCall<'a, C, A> {} -impl<'a, C, NC, A> AdunitCustomchannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdunitCustomchannelListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2791,7 +2787,7 @@ impl<'a, C, NC, A> AdunitCustomchannelListCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Ad client which contains the ad unit. - pub fn ad_client_id(mut self, new_value: &str) -> AdunitCustomchannelListCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AdunitCustomchannelListCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -2801,7 +2797,7 @@ impl<'a, C, NC, A> AdunitCustomchannelListCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Ad unit for which to list custom channels. - pub fn ad_unit_id(mut self, new_value: &str) -> AdunitCustomchannelListCall<'a, C, NC, A> { + pub fn ad_unit_id(mut self, new_value: &str) -> AdunitCustomchannelListCall<'a, C, A> { self._ad_unit_id = new_value.to_string(); self } @@ -2809,7 +2805,7 @@ impl<'a, C, NC, A> AdunitCustomchannelListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// A continuation token, used to page through custom channels. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> AdunitCustomchannelListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AdunitCustomchannelListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2817,7 +2813,7 @@ impl<'a, C, NC, A> AdunitCustomchannelListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// The maximum number of custom channels to include in the response, used for paging. - pub fn max_results(mut self, new_value: i32) -> AdunitCustomchannelListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AdunitCustomchannelListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2828,7 +2824,7 @@ impl<'a, C, NC, A> AdunitCustomchannelListCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdunitCustomchannelListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdunitCustomchannelListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2849,7 +2845,7 @@ impl<'a, C, NC, A> AdunitCustomchannelListCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdunitCustomchannelListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdunitCustomchannelListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2866,7 +2862,7 @@ impl<'a, C, NC, A> AdunitCustomchannelListCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AdunitCustomchannelListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AdunitCustomchannelListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2904,10 +2900,10 @@ impl<'a, C, NC, A> AdunitCustomchannelListCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct AdunitGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdunitGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _ad_client_id: String, _ad_unit_id: String, _delegate: Option<&'a mut Delegate>, @@ -2915,9 +2911,9 @@ pub struct AdunitGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AdunitGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdunitGetCall<'a, C, A> {} -impl<'a, C, NC, A> AdunitGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdunitGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3050,7 +3046,7 @@ impl<'a, C, NC, A> AdunitGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Ad client for which to get the ad unit. - pub fn ad_client_id(mut self, new_value: &str) -> AdunitGetCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AdunitGetCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -3060,7 +3056,7 @@ impl<'a, C, NC, A> AdunitGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Ad unit to retrieve. - pub fn ad_unit_id(mut self, new_value: &str) -> AdunitGetCall<'a, C, NC, A> { + pub fn ad_unit_id(mut self, new_value: &str) -> AdunitGetCall<'a, C, A> { self._ad_unit_id = new_value.to_string(); self } @@ -3071,7 +3067,7 @@ impl<'a, C, NC, A> AdunitGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdunitGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdunitGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3092,7 +3088,7 @@ impl<'a, C, NC, A> AdunitGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdunitGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdunitGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3109,7 +3105,7 @@ impl<'a, C, NC, A> AdunitGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AdunitGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AdunitGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3150,10 +3146,10 @@ impl<'a, C, NC, A> AdunitGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct AdunitListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdunitListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _ad_client_id: String, _page_token: Option, _max_results: Option, @@ -3163,9 +3159,9 @@ pub struct AdunitListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AdunitListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdunitListCall<'a, C, A> {} -impl<'a, C, NC, A> AdunitListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdunitListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3306,7 +3302,7 @@ impl<'a, C, NC, A> AdunitListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Ad client for which to list ad units. - pub fn ad_client_id(mut self, new_value: &str) -> AdunitListCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AdunitListCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -3314,7 +3310,7 @@ impl<'a, C, NC, A> AdunitListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// A continuation token, used to page through ad units. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> AdunitListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AdunitListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -3322,7 +3318,7 @@ impl<'a, C, NC, A> AdunitListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The maximum number of ad units to include in the response, used for paging. - pub fn max_results(mut self, new_value: i32) -> AdunitListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AdunitListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -3330,7 +3326,7 @@ impl<'a, C, NC, A> AdunitListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether to include inactive ad units. Default: true. - pub fn include_inactive(mut self, new_value: bool) -> AdunitListCall<'a, C, NC, A> { + pub fn include_inactive(mut self, new_value: bool) -> AdunitListCall<'a, C, A> { self._include_inactive = Some(new_value); self } @@ -3341,7 +3337,7 @@ impl<'a, C, NC, A> AdunitListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdunitListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdunitListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3362,7 +3358,7 @@ impl<'a, C, NC, A> AdunitListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdunitListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdunitListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3379,7 +3375,7 @@ impl<'a, C, NC, A> AdunitListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AdunitListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AdunitListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3417,10 +3413,10 @@ impl<'a, C, NC, A> AdunitListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct AdunitGetAdCodeCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdunitGetAdCodeCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _ad_client_id: String, _ad_unit_id: String, _delegate: Option<&'a mut Delegate>, @@ -3428,9 +3424,9 @@ pub struct AdunitGetAdCodeCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AdunitGetAdCodeCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdunitGetAdCodeCall<'a, C, A> {} -impl<'a, C, NC, A> AdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdunitGetAdCodeCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3563,7 +3559,7 @@ impl<'a, C, NC, A> AdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Ad client with contains the ad unit. - pub fn ad_client_id(mut self, new_value: &str) -> AdunitGetAdCodeCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AdunitGetAdCodeCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -3573,7 +3569,7 @@ impl<'a, C, NC, A> AdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Ad unit to get the code for. - pub fn ad_unit_id(mut self, new_value: &str) -> AdunitGetAdCodeCall<'a, C, NC, A> { + pub fn ad_unit_id(mut self, new_value: &str) -> AdunitGetAdCodeCall<'a, C, A> { self._ad_unit_id = new_value.to_string(); self } @@ -3584,7 +3580,7 @@ impl<'a, C, NC, A> AdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdunitGetAdCodeCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdunitGetAdCodeCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3605,7 +3601,7 @@ impl<'a, C, NC, A> AdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdunitGetAdCodeCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdunitGetAdCodeCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3622,7 +3618,7 @@ impl<'a, C, NC, A> AdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AdunitGetAdCodeCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AdunitGetAdCodeCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3662,10 +3658,10 @@ impl<'a, C, NC, A> AdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct AdclientListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdclientListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _page_token: Option, _max_results: Option, _delegate: Option<&'a mut Delegate>, @@ -3673,9 +3669,9 @@ pub struct AdclientListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AdclientListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdclientListCall<'a, C, A> {} -impl<'a, C, NC, A> AdclientListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdclientListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3786,7 +3782,7 @@ impl<'a, C, NC, A> AdclientListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// A continuation token, used to page through ad clients. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> AdclientListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AdclientListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -3794,7 +3790,7 @@ impl<'a, C, NC, A> AdclientListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The maximum number of ad clients to include in the response, used for paging. - pub fn max_results(mut self, new_value: i32) -> AdclientListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AdclientListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -3805,7 +3801,7 @@ impl<'a, C, NC, A> AdclientListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdclientListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdclientListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3826,7 +3822,7 @@ impl<'a, C, NC, A> AdclientListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdclientListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdclientListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3843,7 +3839,7 @@ impl<'a, C, NC, A> AdclientListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AdclientListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AdclientListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3881,19 +3877,19 @@ impl<'a, C, NC, A> AdclientListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct AlertDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AlertDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _alert_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AlertDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AlertDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> AlertDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AlertDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4014,7 +4010,7 @@ impl<'a, C, NC, A> AlertDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Alert to delete. - pub fn alert_id(mut self, new_value: &str) -> AlertDeleteCall<'a, C, NC, A> { + pub fn alert_id(mut self, new_value: &str) -> AlertDeleteCall<'a, C, A> { self._alert_id = new_value.to_string(); self } @@ -4025,7 +4021,7 @@ impl<'a, C, NC, A> AlertDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AlertDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AlertDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4046,7 +4042,7 @@ impl<'a, C, NC, A> AlertDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AlertDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AlertDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4063,7 +4059,7 @@ impl<'a, C, NC, A> AlertDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AlertDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AlertDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4102,19 +4098,19 @@ impl<'a, C, NC, A> AlertDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct AlertListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AlertListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _locale: Option, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AlertListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AlertListCall<'a, C, A> {} -impl<'a, C, NC, A> AlertListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AlertListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4222,7 +4218,7 @@ impl<'a, C, NC, A> AlertListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The locale to use for translating alert messages. The account locale will be used if this is not supplied. The AdSense default (English) will be used if the supplied locale is invalid or unsupported. - pub fn locale(mut self, new_value: &str) -> AlertListCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> AlertListCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -4233,7 +4229,7 @@ impl<'a, C, NC, A> AlertListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AlertListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AlertListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4254,7 +4250,7 @@ impl<'a, C, NC, A> AlertListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AlertListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AlertListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4271,7 +4267,7 @@ impl<'a, C, NC, A> AlertListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AlertListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AlertListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4311,10 +4307,10 @@ impl<'a, C, NC, A> AlertListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct SavedadstyleListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SavedadstyleListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _page_token: Option, _max_results: Option, _delegate: Option<&'a mut Delegate>, @@ -4322,9 +4318,9 @@ pub struct SavedadstyleListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SavedadstyleListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SavedadstyleListCall<'a, C, A> {} -impl<'a, C, NC, A> SavedadstyleListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SavedadstyleListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4435,7 +4431,7 @@ impl<'a, C, NC, A> SavedadstyleListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// A continuation token, used to page through saved ad styles. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> SavedadstyleListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> SavedadstyleListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -4443,7 +4439,7 @@ impl<'a, C, NC, A> SavedadstyleListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The maximum number of saved ad styles to include in the response, used for paging. - pub fn max_results(mut self, new_value: i32) -> SavedadstyleListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> SavedadstyleListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -4454,7 +4450,7 @@ impl<'a, C, NC, A> SavedadstyleListCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SavedadstyleListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SavedadstyleListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4475,7 +4471,7 @@ impl<'a, C, NC, A> SavedadstyleListCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SavedadstyleListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SavedadstyleListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4492,7 +4488,7 @@ impl<'a, C, NC, A> SavedadstyleListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SavedadstyleListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SavedadstyleListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4530,19 +4526,19 @@ impl<'a, C, NC, A> SavedadstyleListCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct SavedadstyleGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SavedadstyleGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _saved_ad_style_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SavedadstyleGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SavedadstyleGetCall<'a, C, A> {} -impl<'a, C, NC, A> SavedadstyleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SavedadstyleGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4674,7 +4670,7 @@ impl<'a, C, NC, A> SavedadstyleGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Saved ad style to retrieve. - pub fn saved_ad_style_id(mut self, new_value: &str) -> SavedadstyleGetCall<'a, C, NC, A> { + pub fn saved_ad_style_id(mut self, new_value: &str) -> SavedadstyleGetCall<'a, C, A> { self._saved_ad_style_id = new_value.to_string(); self } @@ -4685,7 +4681,7 @@ impl<'a, C, NC, A> SavedadstyleGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SavedadstyleGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SavedadstyleGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4706,7 +4702,7 @@ impl<'a, C, NC, A> SavedadstyleGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SavedadstyleGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SavedadstyleGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4723,7 +4719,7 @@ impl<'a, C, NC, A> SavedadstyleGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SavedadstyleGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SavedadstyleGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4763,10 +4759,10 @@ impl<'a, C, NC, A> SavedadstyleGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct ReportSavedListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportSavedListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _page_token: Option, _max_results: Option, _delegate: Option<&'a mut Delegate>, @@ -4774,9 +4770,9 @@ pub struct ReportSavedListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReportSavedListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReportSavedListCall<'a, C, A> {} -impl<'a, C, NC, A> ReportSavedListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReportSavedListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4887,7 +4883,7 @@ impl<'a, C, NC, A> ReportSavedListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// A continuation token, used to page through saved reports. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> ReportSavedListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ReportSavedListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -4895,7 +4891,7 @@ impl<'a, C, NC, A> ReportSavedListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The maximum number of saved reports to include in the response, used for paging. - pub fn max_results(mut self, new_value: i32) -> ReportSavedListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ReportSavedListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -4906,7 +4902,7 @@ impl<'a, C, NC, A> ReportSavedListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportSavedListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportSavedListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4927,7 +4923,7 @@ impl<'a, C, NC, A> ReportSavedListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReportSavedListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReportSavedListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4944,7 +4940,7 @@ impl<'a, C, NC, A> ReportSavedListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReportSavedListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReportSavedListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4997,10 +4993,10 @@ impl<'a, C, NC, A> ReportSavedListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct ReportGenerateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportGenerateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _start_date: String, _end_date: String, _use_timezone_reporting: Option, @@ -5018,9 +5014,9 @@ pub struct ReportGenerateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReportGenerateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReportGenerateCall<'a, C, A> {} -impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReportGenerateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5195,7 +5191,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Start of the date range to report on in "YYYY-MM-DD" format, inclusive. - pub fn start_date(mut self, new_value: &str) -> ReportGenerateCall<'a, C, NC, A> { + pub fn start_date(mut self, new_value: &str) -> ReportGenerateCall<'a, C, A> { self._start_date = new_value.to_string(); self } @@ -5205,7 +5201,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// End of the date range to report on in "YYYY-MM-DD" format, inclusive. - pub fn end_date(mut self, new_value: &str) -> ReportGenerateCall<'a, C, NC, A> { + pub fn end_date(mut self, new_value: &str) -> ReportGenerateCall<'a, C, A> { self._end_date = new_value.to_string(); self } @@ -5213,7 +5209,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Whether the report should be generated in the AdSense account's local timezone. If false default PST/PDT timezone will be used. - pub fn use_timezone_reporting(mut self, new_value: bool) -> ReportGenerateCall<'a, C, NC, A> { + pub fn use_timezone_reporting(mut self, new_value: bool) -> ReportGenerateCall<'a, C, A> { self._use_timezone_reporting = Some(new_value); self } @@ -5221,7 +5217,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Index of the first row of report data to return. - pub fn start_index(mut self, new_value: i32) -> ReportGenerateCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> ReportGenerateCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -5230,7 +5226,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The name of a dimension or metric to sort the resulting report on, optionally prefixed with "+" to sort ascending or "-" to sort descending. If no prefix is specified, the column is sorted ascending. - pub fn add_sort(mut self, new_value: &str) -> ReportGenerateCall<'a, C, NC, A> { + pub fn add_sort(mut self, new_value: &str) -> ReportGenerateCall<'a, C, A> { self._sort.push(new_value.to_string()); self } @@ -5239,7 +5235,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Numeric columns to include in the report. - pub fn add_metric(mut self, new_value: &str) -> ReportGenerateCall<'a, C, NC, A> { + pub fn add_metric(mut self, new_value: &str) -> ReportGenerateCall<'a, C, A> { self._metric.push(new_value.to_string()); self } @@ -5247,7 +5243,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The maximum number of rows of report data to return. - pub fn max_results(mut self, new_value: i32) -> ReportGenerateCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ReportGenerateCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -5255,7 +5251,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Optional locale to use for translating report output to a local language. Defaults to "en_US" if not specified. - pub fn locale(mut self, new_value: &str) -> ReportGenerateCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> ReportGenerateCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -5264,7 +5260,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Filters to be run on the report. - pub fn add_filter(mut self, new_value: &str) -> ReportGenerateCall<'a, C, NC, A> { + pub fn add_filter(mut self, new_value: &str) -> ReportGenerateCall<'a, C, A> { self._filter.push(new_value.to_string()); self } @@ -5273,7 +5269,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Dimensions to base the report on. - pub fn add_dimension(mut self, new_value: &str) -> ReportGenerateCall<'a, C, NC, A> { + pub fn add_dimension(mut self, new_value: &str) -> ReportGenerateCall<'a, C, A> { self._dimension.push(new_value.to_string()); self } @@ -5281,7 +5277,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Optional currency to use when reporting on monetary metrics. Defaults to the account's currency if not set. - pub fn currency(mut self, new_value: &str) -> ReportGenerateCall<'a, C, NC, A> { + pub fn currency(mut self, new_value: &str) -> ReportGenerateCall<'a, C, A> { self._currency = Some(new_value.to_string()); self } @@ -5290,7 +5286,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Accounts upon which to report. - pub fn add_account_id(mut self, new_value: &str) -> ReportGenerateCall<'a, C, NC, A> { + pub fn add_account_id(mut self, new_value: &str) -> ReportGenerateCall<'a, C, A> { self._account_id.push(new_value.to_string()); self } @@ -5301,7 +5297,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportGenerateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportGenerateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5322,7 +5318,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReportGenerateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReportGenerateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5339,7 +5335,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReportGenerateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReportGenerateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5380,10 +5376,10 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct ReportSavedGenerateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportSavedGenerateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _saved_report_id: String, _start_index: Option, _max_results: Option, @@ -5393,9 +5389,9 @@ pub struct ReportSavedGenerateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReportSavedGenerateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReportSavedGenerateCall<'a, C, A> {} -impl<'a, C, NC, A> ReportSavedGenerateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReportSavedGenerateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5536,7 +5532,7 @@ impl<'a, C, NC, A> ReportSavedGenerateCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The saved report to retrieve. - pub fn saved_report_id(mut self, new_value: &str) -> ReportSavedGenerateCall<'a, C, NC, A> { + pub fn saved_report_id(mut self, new_value: &str) -> ReportSavedGenerateCall<'a, C, A> { self._saved_report_id = new_value.to_string(); self } @@ -5544,7 +5540,7 @@ impl<'a, C, NC, A> ReportSavedGenerateCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Index of the first row of report data to return. - pub fn start_index(mut self, new_value: i32) -> ReportSavedGenerateCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> ReportSavedGenerateCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -5552,7 +5548,7 @@ impl<'a, C, NC, A> ReportSavedGenerateCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The maximum number of rows of report data to return. - pub fn max_results(mut self, new_value: i32) -> ReportSavedGenerateCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ReportSavedGenerateCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -5560,7 +5556,7 @@ impl<'a, C, NC, A> ReportSavedGenerateCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Optional locale to use for translating report output to a local language. Defaults to "en_US" if not specified. - pub fn locale(mut self, new_value: &str) -> ReportSavedGenerateCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> ReportSavedGenerateCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -5571,7 +5567,7 @@ impl<'a, C, NC, A> ReportSavedGenerateCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportSavedGenerateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportSavedGenerateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5592,7 +5588,7 @@ impl<'a, C, NC, A> ReportSavedGenerateCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReportSavedGenerateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReportSavedGenerateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5609,7 +5605,7 @@ impl<'a, C, NC, A> ReportSavedGenerateCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReportSavedGenerateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReportSavedGenerateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5647,10 +5643,10 @@ impl<'a, C, NC, A> ReportSavedGenerateCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct AccountAlertDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountAlertDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _account_id: String, _alert_id: String, _delegate: Option<&'a mut Delegate>, @@ -5658,9 +5654,9 @@ pub struct AccountAlertDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountAlertDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountAlertDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> AccountAlertDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountAlertDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5782,7 +5778,7 @@ impl<'a, C, NC, A> AccountAlertDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Account which contains the ad unit. - pub fn account_id(mut self, new_value: &str) -> AccountAlertDeleteCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountAlertDeleteCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -5792,7 +5788,7 @@ impl<'a, C, NC, A> AccountAlertDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Alert to delete. - pub fn alert_id(mut self, new_value: &str) -> AccountAlertDeleteCall<'a, C, NC, A> { + pub fn alert_id(mut self, new_value: &str) -> AccountAlertDeleteCall<'a, C, A> { self._alert_id = new_value.to_string(); self } @@ -5803,7 +5799,7 @@ impl<'a, C, NC, A> AccountAlertDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAlertDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAlertDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5824,7 +5820,7 @@ impl<'a, C, NC, A> AccountAlertDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountAlertDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountAlertDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5841,7 +5837,7 @@ impl<'a, C, NC, A> AccountAlertDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountAlertDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountAlertDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5880,10 +5876,10 @@ impl<'a, C, NC, A> AccountAlertDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct AccountAlertListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountAlertListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _account_id: String, _locale: Option, _delegate: Option<&'a mut Delegate>, @@ -5891,9 +5887,9 @@ pub struct AccountAlertListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountAlertListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountAlertListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountAlertListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountAlertListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6028,7 +6024,7 @@ impl<'a, C, NC, A> AccountAlertListCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Account for which to retrieve the alerts. - pub fn account_id(mut self, new_value: &str) -> AccountAlertListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountAlertListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -6036,7 +6032,7 @@ impl<'a, C, NC, A> AccountAlertListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The locale to use for translating alert messages. The account locale will be used if this is not supplied. The AdSense default (English) will be used if the supplied locale is invalid or unsupported. - pub fn locale(mut self, new_value: &str) -> AccountAlertListCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> AccountAlertListCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -6047,7 +6043,7 @@ impl<'a, C, NC, A> AccountAlertListCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAlertListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAlertListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6068,7 +6064,7 @@ impl<'a, C, NC, A> AccountAlertListCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountAlertListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountAlertListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6085,7 +6081,7 @@ impl<'a, C, NC, A> AccountAlertListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountAlertListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountAlertListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6126,10 +6122,10 @@ impl<'a, C, NC, A> AccountAlertListCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct AccountReportSavedGenerateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountReportSavedGenerateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _account_id: String, _saved_report_id: String, _start_index: Option, @@ -6140,9 +6136,9 @@ pub struct AccountReportSavedGenerateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountReportSavedGenerateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountReportSavedGenerateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountReportSavedGenerateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountReportSavedGenerateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6284,7 +6280,7 @@ impl<'a, C, NC, A> AccountReportSavedGenerateCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Account to which the saved reports belong. - pub fn account_id(mut self, new_value: &str) -> AccountReportSavedGenerateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountReportSavedGenerateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -6294,7 +6290,7 @@ impl<'a, C, NC, A> AccountReportSavedGenerateCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The saved report to retrieve. - pub fn saved_report_id(mut self, new_value: &str) -> AccountReportSavedGenerateCall<'a, C, NC, A> { + pub fn saved_report_id(mut self, new_value: &str) -> AccountReportSavedGenerateCall<'a, C, A> { self._saved_report_id = new_value.to_string(); self } @@ -6302,7 +6298,7 @@ impl<'a, C, NC, A> AccountReportSavedGenerateCall<'a, C, NC, A> where NC: hyper: /// /// /// Index of the first row of report data to return. - pub fn start_index(mut self, new_value: i32) -> AccountReportSavedGenerateCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> AccountReportSavedGenerateCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -6310,7 +6306,7 @@ impl<'a, C, NC, A> AccountReportSavedGenerateCall<'a, C, NC, A> where NC: hyper: /// /// /// The maximum number of rows of report data to return. - pub fn max_results(mut self, new_value: i32) -> AccountReportSavedGenerateCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AccountReportSavedGenerateCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -6318,7 +6314,7 @@ impl<'a, C, NC, A> AccountReportSavedGenerateCall<'a, C, NC, A> where NC: hyper: /// /// /// Optional locale to use for translating report output to a local language. Defaults to "en_US" if not specified. - pub fn locale(mut self, new_value: &str) -> AccountReportSavedGenerateCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> AccountReportSavedGenerateCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -6329,7 +6325,7 @@ impl<'a, C, NC, A> AccountReportSavedGenerateCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountReportSavedGenerateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountReportSavedGenerateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6350,7 +6346,7 @@ impl<'a, C, NC, A> AccountReportSavedGenerateCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountReportSavedGenerateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountReportSavedGenerateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6367,7 +6363,7 @@ impl<'a, C, NC, A> AccountReportSavedGenerateCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountReportSavedGenerateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountReportSavedGenerateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6407,10 +6403,10 @@ impl<'a, C, NC, A> AccountReportSavedGenerateCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct AccountListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _page_token: Option, _max_results: Option, _delegate: Option<&'a mut Delegate>, @@ -6418,9 +6414,9 @@ pub struct AccountListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6531,7 +6527,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// A continuation token, used to page through accounts. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> AccountListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AccountListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -6539,7 +6535,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The maximum number of accounts to include in the response, used for paging. - pub fn max_results(mut self, new_value: i32) -> AccountListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AccountListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -6550,7 +6546,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6571,7 +6567,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6588,7 +6584,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6626,19 +6622,19 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct AccountPaymentListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountPaymentListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _account_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountPaymentListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountPaymentListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountPaymentListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountPaymentListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6770,7 +6766,7 @@ impl<'a, C, NC, A> AccountPaymentListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Account for which to retrieve the payments. - pub fn account_id(mut self, new_value: &str) -> AccountPaymentListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountPaymentListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -6781,7 +6777,7 @@ impl<'a, C, NC, A> AccountPaymentListCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPaymentListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPaymentListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6802,7 +6798,7 @@ impl<'a, C, NC, A> AccountPaymentListCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountPaymentListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountPaymentListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6819,7 +6815,7 @@ impl<'a, C, NC, A> AccountPaymentListCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountPaymentListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountPaymentListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6857,10 +6853,10 @@ impl<'a, C, NC, A> AccountPaymentListCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct AccountSavedadstyleGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountSavedadstyleGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _account_id: String, _saved_ad_style_id: String, _delegate: Option<&'a mut Delegate>, @@ -6868,9 +6864,9 @@ pub struct AccountSavedadstyleGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountSavedadstyleGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountSavedadstyleGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountSavedadstyleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountSavedadstyleGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7003,7 +6999,7 @@ impl<'a, C, NC, A> AccountSavedadstyleGetCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Account for which to get the saved ad style. - pub fn account_id(mut self, new_value: &str) -> AccountSavedadstyleGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountSavedadstyleGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -7013,7 +7009,7 @@ impl<'a, C, NC, A> AccountSavedadstyleGetCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Saved ad style to retrieve. - pub fn saved_ad_style_id(mut self, new_value: &str) -> AccountSavedadstyleGetCall<'a, C, NC, A> { + pub fn saved_ad_style_id(mut self, new_value: &str) -> AccountSavedadstyleGetCall<'a, C, A> { self._saved_ad_style_id = new_value.to_string(); self } @@ -7024,7 +7020,7 @@ impl<'a, C, NC, A> AccountSavedadstyleGetCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountSavedadstyleGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountSavedadstyleGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7045,7 +7041,7 @@ impl<'a, C, NC, A> AccountSavedadstyleGetCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountSavedadstyleGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountSavedadstyleGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7062,7 +7058,7 @@ impl<'a, C, NC, A> AccountSavedadstyleGetCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountSavedadstyleGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountSavedadstyleGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7100,10 +7096,10 @@ impl<'a, C, NC, A> AccountSavedadstyleGetCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct AccountAdunitGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountAdunitGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _account_id: String, _ad_client_id: String, _ad_unit_id: String, @@ -7112,9 +7108,9 @@ pub struct AccountAdunitGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountAdunitGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountAdunitGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountAdunitGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountAdunitGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7248,7 +7244,7 @@ impl<'a, C, NC, A> AccountAdunitGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Account to which the ad client belongs. - pub fn account_id(mut self, new_value: &str) -> AccountAdunitGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountAdunitGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -7258,7 +7254,7 @@ impl<'a, C, NC, A> AccountAdunitGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Ad client for which to get the ad unit. - pub fn ad_client_id(mut self, new_value: &str) -> AccountAdunitGetCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AccountAdunitGetCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -7268,7 +7264,7 @@ impl<'a, C, NC, A> AccountAdunitGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Ad unit to retrieve. - pub fn ad_unit_id(mut self, new_value: &str) -> AccountAdunitGetCall<'a, C, NC, A> { + pub fn ad_unit_id(mut self, new_value: &str) -> AccountAdunitGetCall<'a, C, A> { self._ad_unit_id = new_value.to_string(); self } @@ -7279,7 +7275,7 @@ impl<'a, C, NC, A> AccountAdunitGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdunitGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdunitGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7300,7 +7296,7 @@ impl<'a, C, NC, A> AccountAdunitGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountAdunitGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountAdunitGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7317,7 +7313,7 @@ impl<'a, C, NC, A> AccountAdunitGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountAdunitGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountAdunitGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7355,10 +7351,10 @@ impl<'a, C, NC, A> AccountAdunitGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct AccountCustomchannelGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountCustomchannelGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _account_id: String, _ad_client_id: String, _custom_channel_id: String, @@ -7367,9 +7363,9 @@ pub struct AccountCustomchannelGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountCustomchannelGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountCustomchannelGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountCustomchannelGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountCustomchannelGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7503,7 +7499,7 @@ impl<'a, C, NC, A> AccountCustomchannelGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Account to which the ad client belongs. - pub fn account_id(mut self, new_value: &str) -> AccountCustomchannelGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountCustomchannelGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -7513,7 +7509,7 @@ impl<'a, C, NC, A> AccountCustomchannelGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Ad client which contains the custom channel. - pub fn ad_client_id(mut self, new_value: &str) -> AccountCustomchannelGetCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AccountCustomchannelGetCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -7523,7 +7519,7 @@ impl<'a, C, NC, A> AccountCustomchannelGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Custom channel to retrieve. - pub fn custom_channel_id(mut self, new_value: &str) -> AccountCustomchannelGetCall<'a, C, NC, A> { + pub fn custom_channel_id(mut self, new_value: &str) -> AccountCustomchannelGetCall<'a, C, A> { self._custom_channel_id = new_value.to_string(); self } @@ -7534,7 +7530,7 @@ impl<'a, C, NC, A> AccountCustomchannelGetCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountCustomchannelGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountCustomchannelGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7555,7 +7551,7 @@ impl<'a, C, NC, A> AccountCustomchannelGetCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountCustomchannelGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountCustomchannelGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7572,7 +7568,7 @@ impl<'a, C, NC, A> AccountCustomchannelGetCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountCustomchannelGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountCustomchannelGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7613,10 +7609,10 @@ impl<'a, C, NC, A> AccountCustomchannelGetCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct AccountCustomchannelAdunitListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountCustomchannelAdunitListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _account_id: String, _ad_client_id: String, _custom_channel_id: String, @@ -7628,9 +7624,9 @@ pub struct AccountCustomchannelAdunitListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountCustomchannelAdunitListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountCustomchannelAdunitListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountCustomchannelAdunitListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountCustomchannelAdunitListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7773,7 +7769,7 @@ impl<'a, C, NC, A> AccountCustomchannelAdunitListCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// Account to which the ad client belongs. - pub fn account_id(mut self, new_value: &str) -> AccountCustomchannelAdunitListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountCustomchannelAdunitListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -7783,7 +7779,7 @@ impl<'a, C, NC, A> AccountCustomchannelAdunitListCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// Ad client which contains the custom channel. - pub fn ad_client_id(mut self, new_value: &str) -> AccountCustomchannelAdunitListCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AccountCustomchannelAdunitListCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -7793,7 +7789,7 @@ impl<'a, C, NC, A> AccountCustomchannelAdunitListCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// Custom channel for which to list ad units. - pub fn custom_channel_id(mut self, new_value: &str) -> AccountCustomchannelAdunitListCall<'a, C, NC, A> { + pub fn custom_channel_id(mut self, new_value: &str) -> AccountCustomchannelAdunitListCall<'a, C, A> { self._custom_channel_id = new_value.to_string(); self } @@ -7801,7 +7797,7 @@ impl<'a, C, NC, A> AccountCustomchannelAdunitListCall<'a, C, NC, A> where NC: hy /// /// /// A continuation token, used to page through ad units. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> AccountCustomchannelAdunitListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AccountCustomchannelAdunitListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -7809,7 +7805,7 @@ impl<'a, C, NC, A> AccountCustomchannelAdunitListCall<'a, C, NC, A> where NC: hy /// /// /// The maximum number of ad units to include in the response, used for paging. - pub fn max_results(mut self, new_value: i32) -> AccountCustomchannelAdunitListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AccountCustomchannelAdunitListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -7817,7 +7813,7 @@ impl<'a, C, NC, A> AccountCustomchannelAdunitListCall<'a, C, NC, A> where NC: hy /// /// /// Whether to include inactive ad units. Default: true. - pub fn include_inactive(mut self, new_value: bool) -> AccountCustomchannelAdunitListCall<'a, C, NC, A> { + pub fn include_inactive(mut self, new_value: bool) -> AccountCustomchannelAdunitListCall<'a, C, A> { self._include_inactive = Some(new_value); self } @@ -7828,7 +7824,7 @@ impl<'a, C, NC, A> AccountCustomchannelAdunitListCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountCustomchannelAdunitListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountCustomchannelAdunitListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7849,7 +7845,7 @@ impl<'a, C, NC, A> AccountCustomchannelAdunitListCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountCustomchannelAdunitListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountCustomchannelAdunitListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7866,7 +7862,7 @@ impl<'a, C, NC, A> AccountCustomchannelAdunitListCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountCustomchannelAdunitListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountCustomchannelAdunitListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7906,10 +7902,10 @@ impl<'a, C, NC, A> AccountCustomchannelAdunitListCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct AccountReportSavedListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountReportSavedListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _account_id: String, _page_token: Option, _max_results: Option, @@ -7918,9 +7914,9 @@ pub struct AccountReportSavedListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountReportSavedListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountReportSavedListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountReportSavedListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountReportSavedListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8058,7 +8054,7 @@ impl<'a, C, NC, A> AccountReportSavedListCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Account to which the saved reports belong. - pub fn account_id(mut self, new_value: &str) -> AccountReportSavedListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountReportSavedListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -8066,7 +8062,7 @@ impl<'a, C, NC, A> AccountReportSavedListCall<'a, C, NC, A> where NC: hyper::net /// /// /// A continuation token, used to page through saved reports. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> AccountReportSavedListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AccountReportSavedListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -8074,7 +8070,7 @@ impl<'a, C, NC, A> AccountReportSavedListCall<'a, C, NC, A> where NC: hyper::net /// /// /// The maximum number of saved reports to include in the response, used for paging. - pub fn max_results(mut self, new_value: i32) -> AccountReportSavedListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AccountReportSavedListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -8085,7 +8081,7 @@ impl<'a, C, NC, A> AccountReportSavedListCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountReportSavedListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountReportSavedListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8106,7 +8102,7 @@ impl<'a, C, NC, A> AccountReportSavedListCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountReportSavedListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountReportSavedListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8123,7 +8119,7 @@ impl<'a, C, NC, A> AccountReportSavedListCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountReportSavedListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountReportSavedListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8163,10 +8159,10 @@ impl<'a, C, NC, A> AccountReportSavedListCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct AccountUrlchannelListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountUrlchannelListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _account_id: String, _ad_client_id: String, _page_token: Option, @@ -8176,9 +8172,9 @@ pub struct AccountUrlchannelListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountUrlchannelListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountUrlchannelListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountUrlchannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountUrlchannelListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8317,7 +8313,7 @@ impl<'a, C, NC, A> AccountUrlchannelListCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Account to which the ad client belongs. - pub fn account_id(mut self, new_value: &str) -> AccountUrlchannelListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountUrlchannelListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -8327,7 +8323,7 @@ impl<'a, C, NC, A> AccountUrlchannelListCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Ad client for which to list URL channels. - pub fn ad_client_id(mut self, new_value: &str) -> AccountUrlchannelListCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AccountUrlchannelListCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -8335,7 +8331,7 @@ impl<'a, C, NC, A> AccountUrlchannelListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// A continuation token, used to page through URL channels. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> AccountUrlchannelListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AccountUrlchannelListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -8343,7 +8339,7 @@ impl<'a, C, NC, A> AccountUrlchannelListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// The maximum number of URL channels to include in the response, used for paging. - pub fn max_results(mut self, new_value: i32) -> AccountUrlchannelListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AccountUrlchannelListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -8354,7 +8350,7 @@ impl<'a, C, NC, A> AccountUrlchannelListCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountUrlchannelListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountUrlchannelListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8375,7 +8371,7 @@ impl<'a, C, NC, A> AccountUrlchannelListCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountUrlchannelListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountUrlchannelListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8392,7 +8388,7 @@ impl<'a, C, NC, A> AccountUrlchannelListCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountUrlchannelListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountUrlchannelListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8433,10 +8429,10 @@ impl<'a, C, NC, A> AccountUrlchannelListCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct AccountAdunitListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountAdunitListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _account_id: String, _ad_client_id: String, _page_token: Option, @@ -8447,9 +8443,9 @@ pub struct AccountAdunitListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountAdunitListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountAdunitListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountAdunitListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountAdunitListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8591,7 +8587,7 @@ impl<'a, C, NC, A> AccountAdunitListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Account to which the ad client belongs. - pub fn account_id(mut self, new_value: &str) -> AccountAdunitListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountAdunitListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -8601,7 +8597,7 @@ impl<'a, C, NC, A> AccountAdunitListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Ad client for which to list ad units. - pub fn ad_client_id(mut self, new_value: &str) -> AccountAdunitListCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AccountAdunitListCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -8609,7 +8605,7 @@ impl<'a, C, NC, A> AccountAdunitListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// A continuation token, used to page through ad units. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> AccountAdunitListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AccountAdunitListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -8617,7 +8613,7 @@ impl<'a, C, NC, A> AccountAdunitListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The maximum number of ad units to include in the response, used for paging. - pub fn max_results(mut self, new_value: i32) -> AccountAdunitListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AccountAdunitListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -8625,7 +8621,7 @@ impl<'a, C, NC, A> AccountAdunitListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Whether to include inactive ad units. Default: true. - pub fn include_inactive(mut self, new_value: bool) -> AccountAdunitListCall<'a, C, NC, A> { + pub fn include_inactive(mut self, new_value: bool) -> AccountAdunitListCall<'a, C, A> { self._include_inactive = Some(new_value); self } @@ -8636,7 +8632,7 @@ impl<'a, C, NC, A> AccountAdunitListCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdunitListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdunitListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8657,7 +8653,7 @@ impl<'a, C, NC, A> AccountAdunitListCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountAdunitListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountAdunitListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8674,7 +8670,7 @@ impl<'a, C, NC, A> AccountAdunitListCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountAdunitListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountAdunitListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8726,10 +8722,10 @@ impl<'a, C, NC, A> AccountAdunitListCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct AccountReportGenerateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountReportGenerateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _account_id: String, _start_date: String, _end_date: String, @@ -8747,9 +8743,9 @@ pub struct AccountReportGenerateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountReportGenerateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountReportGenerateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountReportGenerateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8942,7 +8938,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Account upon which to report. - pub fn account_id(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -8952,7 +8948,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Start of the date range to report on in "YYYY-MM-DD" format, inclusive. - pub fn start_date(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn start_date(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._start_date = new_value.to_string(); self } @@ -8962,7 +8958,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// End of the date range to report on in "YYYY-MM-DD" format, inclusive. - pub fn end_date(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn end_date(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._end_date = new_value.to_string(); self } @@ -8970,7 +8966,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Whether the report should be generated in the AdSense account's local timezone. If false default PST/PDT timezone will be used. - pub fn use_timezone_reporting(mut self, new_value: bool) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn use_timezone_reporting(mut self, new_value: bool) -> AccountReportGenerateCall<'a, C, A> { self._use_timezone_reporting = Some(new_value); self } @@ -8978,7 +8974,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Index of the first row of report data to return. - pub fn start_index(mut self, new_value: i32) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> AccountReportGenerateCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -8987,7 +8983,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// The name of a dimension or metric to sort the resulting report on, optionally prefixed with "+" to sort ascending or "-" to sort descending. If no prefix is specified, the column is sorted ascending. - pub fn add_sort(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn add_sort(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._sort.push(new_value.to_string()); self } @@ -8996,7 +8992,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Numeric columns to include in the report. - pub fn add_metric(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn add_metric(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._metric.push(new_value.to_string()); self } @@ -9004,7 +9000,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// The maximum number of rows of report data to return. - pub fn max_results(mut self, new_value: i32) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AccountReportGenerateCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -9012,7 +9008,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Optional locale to use for translating report output to a local language. Defaults to "en_US" if not specified. - pub fn locale(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -9021,7 +9017,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Filters to be run on the report. - pub fn add_filter(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn add_filter(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._filter.push(new_value.to_string()); self } @@ -9030,7 +9026,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Dimensions to base the report on. - pub fn add_dimension(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn add_dimension(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._dimension.push(new_value.to_string()); self } @@ -9038,7 +9034,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Optional currency to use when reporting on monetary metrics. Defaults to the account's currency if not set. - pub fn currency(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn currency(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._currency = Some(new_value.to_string()); self } @@ -9049,7 +9045,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountReportGenerateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9070,7 +9066,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountReportGenerateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountReportGenerateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9087,7 +9083,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountReportGenerateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountReportGenerateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9127,10 +9123,10 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct AccountAdclientListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountAdclientListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _account_id: String, _page_token: Option, _max_results: Option, @@ -9139,9 +9135,9 @@ pub struct AccountAdclientListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountAdclientListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountAdclientListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountAdclientListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9279,7 +9275,7 @@ impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Account for which to list ad clients. - pub fn account_id(mut self, new_value: &str) -> AccountAdclientListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountAdclientListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -9287,7 +9283,7 @@ impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// A continuation token, used to page through ad clients. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> AccountAdclientListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AccountAdclientListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -9295,7 +9291,7 @@ impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The maximum number of ad clients to include in the response, used for paging. - pub fn max_results(mut self, new_value: i32) -> AccountAdclientListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AccountAdclientListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -9306,7 +9302,7 @@ impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdclientListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdclientListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9327,7 +9323,7 @@ impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountAdclientListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountAdclientListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9344,7 +9340,7 @@ impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountAdclientListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountAdclientListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9384,10 +9380,10 @@ impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct AccountCustomchannelListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountCustomchannelListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _account_id: String, _ad_client_id: String, _page_token: Option, @@ -9397,9 +9393,9 @@ pub struct AccountCustomchannelListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountCustomchannelListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountCustomchannelListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountCustomchannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountCustomchannelListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9538,7 +9534,7 @@ impl<'a, C, NC, A> AccountCustomchannelListCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Account to which the ad client belongs. - pub fn account_id(mut self, new_value: &str) -> AccountCustomchannelListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountCustomchannelListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -9548,7 +9544,7 @@ impl<'a, C, NC, A> AccountCustomchannelListCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Ad client for which to list custom channels. - pub fn ad_client_id(mut self, new_value: &str) -> AccountCustomchannelListCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AccountCustomchannelListCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -9556,7 +9552,7 @@ impl<'a, C, NC, A> AccountCustomchannelListCall<'a, C, NC, A> where NC: hyper::n /// /// /// A continuation token, used to page through custom channels. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> AccountCustomchannelListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AccountCustomchannelListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -9564,7 +9560,7 @@ impl<'a, C, NC, A> AccountCustomchannelListCall<'a, C, NC, A> where NC: hyper::n /// /// /// The maximum number of custom channels to include in the response, used for paging. - pub fn max_results(mut self, new_value: i32) -> AccountCustomchannelListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AccountCustomchannelListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -9575,7 +9571,7 @@ impl<'a, C, NC, A> AccountCustomchannelListCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountCustomchannelListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountCustomchannelListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9596,7 +9592,7 @@ impl<'a, C, NC, A> AccountCustomchannelListCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountCustomchannelListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountCustomchannelListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9613,7 +9609,7 @@ impl<'a, C, NC, A> AccountCustomchannelListCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountCustomchannelListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountCustomchannelListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9653,10 +9649,10 @@ impl<'a, C, NC, A> AccountCustomchannelListCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct AccountSavedadstyleListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountSavedadstyleListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _account_id: String, _page_token: Option, _max_results: Option, @@ -9665,9 +9661,9 @@ pub struct AccountSavedadstyleListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountSavedadstyleListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountSavedadstyleListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountSavedadstyleListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountSavedadstyleListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9805,7 +9801,7 @@ impl<'a, C, NC, A> AccountSavedadstyleListCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Account for which to list saved ad styles. - pub fn account_id(mut self, new_value: &str) -> AccountSavedadstyleListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountSavedadstyleListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -9813,7 +9809,7 @@ impl<'a, C, NC, A> AccountSavedadstyleListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// A continuation token, used to page through saved ad styles. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> AccountSavedadstyleListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AccountSavedadstyleListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -9821,7 +9817,7 @@ impl<'a, C, NC, A> AccountSavedadstyleListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// The maximum number of saved ad styles to include in the response, used for paging. - pub fn max_results(mut self, new_value: i32) -> AccountSavedadstyleListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AccountSavedadstyleListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -9832,7 +9828,7 @@ impl<'a, C, NC, A> AccountSavedadstyleListCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountSavedadstyleListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountSavedadstyleListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9853,7 +9849,7 @@ impl<'a, C, NC, A> AccountSavedadstyleListCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountSavedadstyleListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountSavedadstyleListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9870,7 +9866,7 @@ impl<'a, C, NC, A> AccountSavedadstyleListCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountSavedadstyleListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountSavedadstyleListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9908,10 +9904,10 @@ impl<'a, C, NC, A> AccountSavedadstyleListCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct AccountAdunitGetAdCodeCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountAdunitGetAdCodeCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _account_id: String, _ad_client_id: String, _ad_unit_id: String, @@ -9920,9 +9916,9 @@ pub struct AccountAdunitGetAdCodeCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountAdunitGetAdCodeCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountAdunitGetAdCodeCall<'a, C, A> {} -impl<'a, C, NC, A> AccountAdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountAdunitGetAdCodeCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10056,7 +10052,7 @@ impl<'a, C, NC, A> AccountAdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Account which contains the ad client. - pub fn account_id(mut self, new_value: &str) -> AccountAdunitGetAdCodeCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountAdunitGetAdCodeCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -10066,7 +10062,7 @@ impl<'a, C, NC, A> AccountAdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Ad client with contains the ad unit. - pub fn ad_client_id(mut self, new_value: &str) -> AccountAdunitGetAdCodeCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AccountAdunitGetAdCodeCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -10076,7 +10072,7 @@ impl<'a, C, NC, A> AccountAdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Ad unit to get the code for. - pub fn ad_unit_id(mut self, new_value: &str) -> AccountAdunitGetAdCodeCall<'a, C, NC, A> { + pub fn ad_unit_id(mut self, new_value: &str) -> AccountAdunitGetAdCodeCall<'a, C, A> { self._ad_unit_id = new_value.to_string(); self } @@ -10087,7 +10083,7 @@ impl<'a, C, NC, A> AccountAdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdunitGetAdCodeCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdunitGetAdCodeCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10108,7 +10104,7 @@ impl<'a, C, NC, A> AccountAdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountAdunitGetAdCodeCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountAdunitGetAdCodeCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10125,7 +10121,7 @@ impl<'a, C, NC, A> AccountAdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountAdunitGetAdCodeCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountAdunitGetAdCodeCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10165,10 +10161,10 @@ impl<'a, C, NC, A> AccountAdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct AccountAdunitCustomchannelListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountAdunitCustomchannelListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _account_id: String, _ad_client_id: String, _ad_unit_id: String, @@ -10179,9 +10175,9 @@ pub struct AccountAdunitCustomchannelListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountAdunitCustomchannelListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountAdunitCustomchannelListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountAdunitCustomchannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountAdunitCustomchannelListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10321,7 +10317,7 @@ impl<'a, C, NC, A> AccountAdunitCustomchannelListCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// Account to which the ad client belongs. - pub fn account_id(mut self, new_value: &str) -> AccountAdunitCustomchannelListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountAdunitCustomchannelListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -10331,7 +10327,7 @@ impl<'a, C, NC, A> AccountAdunitCustomchannelListCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// Ad client which contains the ad unit. - pub fn ad_client_id(mut self, new_value: &str) -> AccountAdunitCustomchannelListCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AccountAdunitCustomchannelListCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -10341,7 +10337,7 @@ impl<'a, C, NC, A> AccountAdunitCustomchannelListCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// Ad unit for which to list custom channels. - pub fn ad_unit_id(mut self, new_value: &str) -> AccountAdunitCustomchannelListCall<'a, C, NC, A> { + pub fn ad_unit_id(mut self, new_value: &str) -> AccountAdunitCustomchannelListCall<'a, C, A> { self._ad_unit_id = new_value.to_string(); self } @@ -10349,7 +10345,7 @@ impl<'a, C, NC, A> AccountAdunitCustomchannelListCall<'a, C, NC, A> where NC: hy /// /// /// A continuation token, used to page through custom channels. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> AccountAdunitCustomchannelListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AccountAdunitCustomchannelListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -10357,7 +10353,7 @@ impl<'a, C, NC, A> AccountAdunitCustomchannelListCall<'a, C, NC, A> where NC: hy /// /// /// The maximum number of custom channels to include in the response, used for paging. - pub fn max_results(mut self, new_value: i32) -> AccountAdunitCustomchannelListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AccountAdunitCustomchannelListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -10368,7 +10364,7 @@ impl<'a, C, NC, A> AccountAdunitCustomchannelListCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdunitCustomchannelListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdunitCustomchannelListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10389,7 +10385,7 @@ impl<'a, C, NC, A> AccountAdunitCustomchannelListCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountAdunitCustomchannelListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountAdunitCustomchannelListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10406,7 +10402,7 @@ impl<'a, C, NC, A> AccountAdunitCustomchannelListCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountAdunitCustomchannelListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountAdunitCustomchannelListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10445,10 +10441,10 @@ impl<'a, C, NC, A> AccountAdunitCustomchannelListCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct AccountGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _account_id: String, _tree: Option, _delegate: Option<&'a mut Delegate>, @@ -10456,9 +10452,9 @@ pub struct AccountGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10593,7 +10589,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Account to get information about. - pub fn account_id(mut self, new_value: &str) -> AccountGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -10601,7 +10597,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether the tree of sub accounts should be returned. - pub fn tree(mut self, new_value: bool) -> AccountGetCall<'a, C, NC, A> { + pub fn tree(mut self, new_value: bool) -> AccountGetCall<'a, C, A> { self._tree = Some(new_value); self } @@ -10612,7 +10608,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10633,7 +10629,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10650,7 +10646,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10688,18 +10684,18 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct PaymentListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PaymentListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PaymentListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PaymentListCall<'a, C, A> {} -impl<'a, C, NC, A> PaymentListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PaymentListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10807,7 +10803,7 @@ impl<'a, C, NC, A> PaymentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PaymentListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PaymentListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10828,7 +10824,7 @@ impl<'a, C, NC, A> PaymentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PaymentListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PaymentListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10845,7 +10841,7 @@ impl<'a, C, NC, A> PaymentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PaymentListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PaymentListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10883,18 +10879,18 @@ impl<'a, C, NC, A> PaymentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct MetadataDimensionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MetadataDimensionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MetadataDimensionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MetadataDimensionListCall<'a, C, A> {} -impl<'a, C, NC, A> MetadataDimensionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MetadataDimensionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11002,7 +10998,7 @@ impl<'a, C, NC, A> MetadataDimensionListCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MetadataDimensionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MetadataDimensionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11023,7 +11019,7 @@ impl<'a, C, NC, A> MetadataDimensionListCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MetadataDimensionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MetadataDimensionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11040,7 +11036,7 @@ impl<'a, C, NC, A> MetadataDimensionListCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MetadataDimensionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MetadataDimensionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11078,18 +11074,18 @@ impl<'a, C, NC, A> MetadataDimensionListCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct MetadataMetricListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MetadataMetricListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MetadataMetricListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MetadataMetricListCall<'a, C, A> {} -impl<'a, C, NC, A> MetadataMetricListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MetadataMetricListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11197,7 +11193,7 @@ impl<'a, C, NC, A> MetadataMetricListCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MetadataMetricListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MetadataMetricListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11218,7 +11214,7 @@ impl<'a, C, NC, A> MetadataMetricListCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MetadataMetricListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MetadataMetricListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11235,7 +11231,7 @@ impl<'a, C, NC, A> MetadataMetricListCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MetadataMetricListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MetadataMetricListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11273,10 +11269,10 @@ impl<'a, C, NC, A> MetadataMetricListCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct CustomchannelGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CustomchannelGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _ad_client_id: String, _custom_channel_id: String, _delegate: Option<&'a mut Delegate>, @@ -11284,9 +11280,9 @@ pub struct CustomchannelGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CustomchannelGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CustomchannelGetCall<'a, C, A> {} -impl<'a, C, NC, A> CustomchannelGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CustomchannelGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11419,7 +11415,7 @@ impl<'a, C, NC, A> CustomchannelGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Ad client which contains the custom channel. - pub fn ad_client_id(mut self, new_value: &str) -> CustomchannelGetCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> CustomchannelGetCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -11429,7 +11425,7 @@ impl<'a, C, NC, A> CustomchannelGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Custom channel to retrieve. - pub fn custom_channel_id(mut self, new_value: &str) -> CustomchannelGetCall<'a, C, NC, A> { + pub fn custom_channel_id(mut self, new_value: &str) -> CustomchannelGetCall<'a, C, A> { self._custom_channel_id = new_value.to_string(); self } @@ -11440,7 +11436,7 @@ impl<'a, C, NC, A> CustomchannelGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomchannelGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomchannelGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11461,7 +11457,7 @@ impl<'a, C, NC, A> CustomchannelGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CustomchannelGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CustomchannelGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11478,7 +11474,7 @@ impl<'a, C, NC, A> CustomchannelGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CustomchannelGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CustomchannelGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11518,10 +11514,10 @@ impl<'a, C, NC, A> CustomchannelGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct CustomchannelListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CustomchannelListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _ad_client_id: String, _page_token: Option, _max_results: Option, @@ -11530,9 +11526,9 @@ pub struct CustomchannelListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CustomchannelListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CustomchannelListCall<'a, C, A> {} -impl<'a, C, NC, A> CustomchannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CustomchannelListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11670,7 +11666,7 @@ impl<'a, C, NC, A> CustomchannelListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Ad client for which to list custom channels. - pub fn ad_client_id(mut self, new_value: &str) -> CustomchannelListCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> CustomchannelListCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -11678,7 +11674,7 @@ impl<'a, C, NC, A> CustomchannelListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// A continuation token, used to page through custom channels. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> CustomchannelListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> CustomchannelListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -11686,7 +11682,7 @@ impl<'a, C, NC, A> CustomchannelListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The maximum number of custom channels to include in the response, used for paging. - pub fn max_results(mut self, new_value: i32) -> CustomchannelListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> CustomchannelListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -11697,7 +11693,7 @@ impl<'a, C, NC, A> CustomchannelListCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomchannelListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomchannelListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11718,7 +11714,7 @@ impl<'a, C, NC, A> CustomchannelListCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CustomchannelListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CustomchannelListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11735,7 +11731,7 @@ impl<'a, C, NC, A> CustomchannelListCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CustomchannelListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CustomchannelListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11776,10 +11772,10 @@ impl<'a, C, NC, A> CustomchannelListCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct CustomchannelAdunitListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CustomchannelAdunitListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSense, + hub: &'a AdSense, _ad_client_id: String, _custom_channel_id: String, _page_token: Option, @@ -11790,9 +11786,9 @@ pub struct CustomchannelAdunitListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CustomchannelAdunitListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CustomchannelAdunitListCall<'a, C, A> {} -impl<'a, C, NC, A> CustomchannelAdunitListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CustomchannelAdunitListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11934,7 +11930,7 @@ impl<'a, C, NC, A> CustomchannelAdunitListCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Ad client which contains the custom channel. - pub fn ad_client_id(mut self, new_value: &str) -> CustomchannelAdunitListCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> CustomchannelAdunitListCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -11944,7 +11940,7 @@ impl<'a, C, NC, A> CustomchannelAdunitListCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Custom channel for which to list ad units. - pub fn custom_channel_id(mut self, new_value: &str) -> CustomchannelAdunitListCall<'a, C, NC, A> { + pub fn custom_channel_id(mut self, new_value: &str) -> CustomchannelAdunitListCall<'a, C, A> { self._custom_channel_id = new_value.to_string(); self } @@ -11952,7 +11948,7 @@ impl<'a, C, NC, A> CustomchannelAdunitListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// A continuation token, used to page through ad units. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> CustomchannelAdunitListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> CustomchannelAdunitListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -11960,7 +11956,7 @@ impl<'a, C, NC, A> CustomchannelAdunitListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// The maximum number of ad units to include in the response, used for paging. - pub fn max_results(mut self, new_value: i32) -> CustomchannelAdunitListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> CustomchannelAdunitListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -11968,7 +11964,7 @@ impl<'a, C, NC, A> CustomchannelAdunitListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// Whether to include inactive ad units. Default: true. - pub fn include_inactive(mut self, new_value: bool) -> CustomchannelAdunitListCall<'a, C, NC, A> { + pub fn include_inactive(mut self, new_value: bool) -> CustomchannelAdunitListCall<'a, C, A> { self._include_inactive = Some(new_value); self } @@ -11979,7 +11975,7 @@ impl<'a, C, NC, A> CustomchannelAdunitListCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomchannelAdunitListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomchannelAdunitListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12000,7 +11996,7 @@ impl<'a, C, NC, A> CustomchannelAdunitListCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CustomchannelAdunitListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CustomchannelAdunitListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12017,7 +12013,7 @@ impl<'a, C, NC, A> CustomchannelAdunitListCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CustomchannelAdunitListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CustomchannelAdunitListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/adsensehost4d1/Cargo.toml b/gen/adsensehost4d1/Cargo.toml index f9debffa9d8..892ad547ad3 100644 --- a/gen/adsensehost4d1/Cargo.toml +++ b/gen/adsensehost4d1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-adsensehost4d1" -version = "0.1.4+20150326" +version = "0.1.5+20150326" authors = ["Sebastian Thiel "] description = "A complete library to interact with AdSense Host (protocol v4.1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/adsensehost4d1" homepage = "https://developers.google.com/adsense/host/" -documentation = "http://byron.github.io/google-apis-rs/google-adsensehost4d1" +documentation = "http://byron.github.io/google-apis-rs/google_adsensehost4d1" license = "MIT" keywords = ["adsensehost", "google", "protocol", "web", "api"] diff --git a/gen/adsensehost4d1/README.md b/gen/adsensehost4d1/README.md index 03d546a31ab..5c0d3ec1fea 100644 --- a/gen/adsensehost4d1/README.md +++ b/gen/adsensehost4d1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-adsensehost4d1` library allows access to all features of the *Google AdSense Host* service. -This documentation was generated from *AdSense Host* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *adsensehost:v4.1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *AdSense Host* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *adsensehost:v4.1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *AdSense Host* *v4d1* API can be found at the [official documentation site](https://developers.google.com/adsense/host/). diff --git a/gen/adsensehost4d1/src/cmn.rs b/gen/adsensehost4d1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/adsensehost4d1/src/cmn.rs +++ b/gen/adsensehost4d1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/adsensehost4d1/src/lib.rs b/gen/adsensehost4d1/src/lib.rs index a977afbf14b..5925bf797f9 100644 --- a/gen/adsensehost4d1/src/lib.rs +++ b/gen/adsensehost4d1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *AdSense Host* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *adsensehost:v4.1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *AdSense Host* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *adsensehost:v4.1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *AdSense Host* *v4d1* API can be found at the //! [official documentation site](https://developers.google.com/adsense/host/). @@ -216,7 +216,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -314,49 +313,46 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct AdSenseHost { +pub struct AdSenseHost { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for AdSenseHost {} +impl<'a, C, A> Hub for AdSenseHost {} -impl<'a, C, NC, A> AdSenseHost - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdSenseHost + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> AdSenseHost { + pub fn new(client: C, authenticator: A) -> AdSenseHost { AdSenseHost { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn accounts(&'a self) -> AccountMethods<'a, C, NC, A> { + pub fn accounts(&'a self) -> AccountMethods<'a, C, A> { AccountMethods { hub: &self } } - pub fn adclients(&'a self) -> AdclientMethods<'a, C, NC, A> { + pub fn adclients(&'a self) -> AdclientMethods<'a, C, A> { AdclientMethods { hub: &self } } - pub fn associationsessions(&'a self) -> AssociationsessionMethods<'a, C, NC, A> { + pub fn associationsessions(&'a self) -> AssociationsessionMethods<'a, C, A> { AssociationsessionMethods { hub: &self } } - pub fn customchannels(&'a self) -> CustomchannelMethods<'a, C, NC, A> { + pub fn customchannels(&'a self) -> CustomchannelMethods<'a, C, A> { CustomchannelMethods { hub: &self } } - pub fn reports(&'a self) -> ReportMethods<'a, C, NC, A> { + pub fn reports(&'a self) -> ReportMethods<'a, C, A> { ReportMethods { hub: &self } } - pub fn urlchannels(&'a self) -> UrlchannelMethods<'a, C, NC, A> { + pub fn urlchannels(&'a self) -> UrlchannelMethods<'a, C, A> { UrlchannelMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -928,15 +924,15 @@ impl ResponseResult for CustomChannels {} /// let rb = hub.urlchannels(); /// # } /// ``` -pub struct UrlchannelMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlchannelMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, } -impl<'a, C, NC, A> MethodsBuilder for UrlchannelMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for UrlchannelMethods<'a, C, A> {} -impl<'a, C, NC, A> UrlchannelMethods<'a, C, NC, A> { +impl<'a, C, A> UrlchannelMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -946,7 +942,7 @@ impl<'a, C, NC, A> UrlchannelMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `adClientId` - Ad client to which the new URL channel will be added. - pub fn insert(&self, request: &UrlChannel, ad_client_id: &str) -> UrlchannelInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &UrlChannel, ad_client_id: &str) -> UrlchannelInsertCall<'a, C, A> { UrlchannelInsertCall { hub: self.hub, _request: request.clone(), @@ -965,7 +961,7 @@ impl<'a, C, NC, A> UrlchannelMethods<'a, C, NC, A> { /// /// * `adClientId` - Ad client from which to delete the URL channel. /// * `urlChannelId` - URL channel to delete. - pub fn delete(&self, ad_client_id: &str, url_channel_id: &str) -> UrlchannelDeleteCall<'a, C, NC, A> { + pub fn delete(&self, ad_client_id: &str, url_channel_id: &str) -> UrlchannelDeleteCall<'a, C, A> { UrlchannelDeleteCall { hub: self.hub, _ad_client_id: ad_client_id.to_string(), @@ -983,7 +979,7 @@ impl<'a, C, NC, A> UrlchannelMethods<'a, C, NC, A> { /// # Arguments /// /// * `adClientId` - Ad client for which to list URL channels. - pub fn list(&self, ad_client_id: &str) -> UrlchannelListCall<'a, C, NC, A> { + pub fn list(&self, ad_client_id: &str) -> UrlchannelListCall<'a, C, A> { UrlchannelListCall { hub: self.hub, _ad_client_id: ad_client_id.to_string(), @@ -1026,20 +1022,20 @@ impl<'a, C, NC, A> UrlchannelMethods<'a, C, NC, A> { /// let rb = hub.adclients(); /// # } /// ``` -pub struct AdclientMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdclientMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, } -impl<'a, C, NC, A> MethodsBuilder for AdclientMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AdclientMethods<'a, C, A> {} -impl<'a, C, NC, A> AdclientMethods<'a, C, NC, A> { +impl<'a, C, A> AdclientMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// List all host ad clients in this AdSense account. - pub fn list(&self) -> AdclientListCall<'a, C, NC, A> { + pub fn list(&self) -> AdclientListCall<'a, C, A> { AdclientListCall { hub: self.hub, _page_token: Default::default(), @@ -1057,7 +1053,7 @@ impl<'a, C, NC, A> AdclientMethods<'a, C, NC, A> { /// # Arguments /// /// * `adClientId` - Ad client to get. - pub fn get(&self, ad_client_id: &str) -> AdclientGetCall<'a, C, NC, A> { + pub fn get(&self, ad_client_id: &str) -> AdclientGetCall<'a, C, A> { AdclientGetCall { hub: self.hub, _ad_client_id: ad_client_id.to_string(), @@ -1098,15 +1094,15 @@ impl<'a, C, NC, A> AdclientMethods<'a, C, NC, A> { /// let rb = hub.associationsessions(); /// # } /// ``` -pub struct AssociationsessionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AssociationsessionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, } -impl<'a, C, NC, A> MethodsBuilder for AssociationsessionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AssociationsessionMethods<'a, C, A> {} -impl<'a, C, NC, A> AssociationsessionMethods<'a, C, NC, A> { +impl<'a, C, A> AssociationsessionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1116,7 +1112,7 @@ impl<'a, C, NC, A> AssociationsessionMethods<'a, C, NC, A> { /// /// * `productCode` - Products to associate with the user. /// * `websiteUrl` - The URL of the user's hosted website. - pub fn start(&self, product_code: &Vec, website_url: &str) -> AssociationsessionStartCall<'a, C, NC, A> { + pub fn start(&self, product_code: &Vec, website_url: &str) -> AssociationsessionStartCall<'a, C, A> { AssociationsessionStartCall { hub: self.hub, _product_code: product_code.clone(), @@ -1136,7 +1132,7 @@ impl<'a, C, NC, A> AssociationsessionMethods<'a, C, NC, A> { /// # Arguments /// /// * `token` - The token returned to the association callback URL. - pub fn verify(&self, token: &str) -> AssociationsessionVerifyCall<'a, C, NC, A> { + pub fn verify(&self, token: &str) -> AssociationsessionVerifyCall<'a, C, A> { AssociationsessionVerifyCall { hub: self.hub, _token: token.to_string(), @@ -1177,15 +1173,15 @@ impl<'a, C, NC, A> AssociationsessionMethods<'a, C, NC, A> { /// let rb = hub.reports(); /// # } /// ``` -pub struct ReportMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, } -impl<'a, C, NC, A> MethodsBuilder for ReportMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ReportMethods<'a, C, A> {} -impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { +impl<'a, C, A> ReportMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1195,7 +1191,7 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// /// * `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 generate(&self, start_date: &str, end_date: &str) -> ReportGenerateCall<'a, C, NC, A> { + pub fn generate(&self, start_date: &str, end_date: &str) -> ReportGenerateCall<'a, C, A> { ReportGenerateCall { hub: self.hub, _start_date: start_date.to_string(), @@ -1244,15 +1240,15 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// let rb = hub.accounts(); /// # } /// ``` -pub struct AccountMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, } -impl<'a, C, NC, A> MethodsBuilder for AccountMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AccountMethods<'a, C, A> {} -impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { +impl<'a, C, A> AccountMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1262,7 +1258,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `accountId` - Account which contains the ad client. /// * `adClientId` - Ad client for which to list ad units. - pub fn adunits_list(&self, account_id: &str, ad_client_id: &str) -> AccountAdunitListCall<'a, C, NC, A> { + pub fn adunits_list(&self, account_id: &str, ad_client_id: &str) -> AccountAdunitListCall<'a, C, A> { AccountAdunitListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1283,7 +1279,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `filterAdClientId` - Ad clients to list accounts for. - pub fn list(&self, filter_ad_client_id: &Vec) -> AccountListCall<'a, C, NC, A> { + pub fn list(&self, filter_ad_client_id: &Vec) -> AccountListCall<'a, C, A> { AccountListCall { hub: self.hub, _filter_ad_client_id: filter_ad_client_id.clone(), @@ -1302,7 +1298,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - Account which contains the ad client. /// * `adClientId` - Ad client with contains the ad unit. /// * `adUnitId` - Ad unit to get the code for. - pub fn adunits_get_ad_code(&self, account_id: &str, ad_client_id: &str, ad_unit_id: &str) -> AccountAdunitGetAdCodeCall<'a, C, NC, A> { + pub fn adunits_get_ad_code(&self, account_id: &str, ad_client_id: &str, ad_unit_id: &str) -> AccountAdunitGetAdCodeCall<'a, C, A> { AccountAdunitGetAdCodeCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1324,7 +1320,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - Hosted account upon which to 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, C, NC, A> { + pub fn reports_generate(&self, account_id: &str, start_date: &str, end_date: &str) -> AccountReportGenerateCall<'a, C, A> { AccountReportGenerateCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1352,7 +1348,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - Account which contains the ad unit. /// * `adClientId` - Ad client for which to get ad unit. /// * `adUnitId` - Ad unit to delete. - pub fn adunits_delete(&self, account_id: &str, ad_client_id: &str, ad_unit_id: &str) -> AccountAdunitDeleteCall<'a, C, NC, A> { + pub fn adunits_delete(&self, account_id: &str, ad_client_id: &str, ad_unit_id: &str) -> AccountAdunitDeleteCall<'a, C, A> { AccountAdunitDeleteCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1371,7 +1367,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `accountId` - Account for which to list ad clients. - pub fn adclients_list(&self, account_id: &str) -> AccountAdclientListCall<'a, C, NC, A> { + pub fn adclients_list(&self, account_id: &str) -> AccountAdclientListCall<'a, C, A> { AccountAdclientListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1393,7 +1389,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - Account which contains the ad client. /// * `adClientId` - Ad client which contains the ad unit. /// * `adUnitId` - Ad unit to get. - pub fn adunits_patch(&self, request: &AdUnit, account_id: &str, ad_client_id: &str, ad_unit_id: &str) -> AccountAdunitPatchCall<'a, C, NC, A> { + pub fn adunits_patch(&self, request: &AdUnit, account_id: &str, ad_client_id: &str, ad_unit_id: &str) -> AccountAdunitPatchCall<'a, C, A> { AccountAdunitPatchCall { hub: self.hub, _request: request.clone(), @@ -1414,7 +1410,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `accountId` - Account which contains the ad client. /// * `adClientId` - Ad client to get. - pub fn adclients_get(&self, account_id: &str, ad_client_id: &str) -> AccountAdclientGetCall<'a, C, NC, A> { + pub fn adclients_get(&self, account_id: &str, ad_client_id: &str) -> AccountAdclientGetCall<'a, C, A> { AccountAdclientGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1432,7 +1428,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `accountId` - Account to get information about. - pub fn get(&self, account_id: &str) -> AccountGetCall<'a, C, NC, A> { + pub fn get(&self, account_id: &str) -> AccountGetCall<'a, C, A> { AccountGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1451,7 +1447,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - Account which will contain the ad unit. /// * `adClientId` - Ad client into which to insert the ad unit. - pub fn adunits_insert(&self, request: &AdUnit, account_id: &str, ad_client_id: &str) -> AccountAdunitInsertCall<'a, C, NC, A> { + pub fn adunits_insert(&self, request: &AdUnit, account_id: &str, ad_client_id: &str) -> AccountAdunitInsertCall<'a, C, A> { AccountAdunitInsertCall { hub: self.hub, _request: request.clone(), @@ -1472,7 +1468,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - Account which contains the ad unit. /// * `adClientId` - Ad client for which to get ad unit. /// * `adUnitId` - Ad unit to get. - pub fn adunits_get(&self, account_id: &str, ad_client_id: &str, ad_unit_id: &str) -> AccountAdunitGetCall<'a, C, NC, A> { + pub fn adunits_get(&self, account_id: &str, ad_client_id: &str, ad_unit_id: &str) -> AccountAdunitGetCall<'a, C, A> { AccountAdunitGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1493,7 +1489,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - Account which contains the ad client. /// * `adClientId` - Ad client which contains the ad unit. - pub fn adunits_update(&self, request: &AdUnit, account_id: &str, ad_client_id: &str) -> AccountAdunitUpdateCall<'a, C, NC, A> { + pub fn adunits_update(&self, request: &AdUnit, account_id: &str, ad_client_id: &str) -> AccountAdunitUpdateCall<'a, C, A> { AccountAdunitUpdateCall { hub: self.hub, _request: request.clone(), @@ -1536,15 +1532,15 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// let rb = hub.customchannels(); /// # } /// ``` -pub struct CustomchannelMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CustomchannelMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, } -impl<'a, C, NC, A> MethodsBuilder for CustomchannelMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CustomchannelMethods<'a, C, A> {} -impl<'a, C, NC, A> CustomchannelMethods<'a, C, NC, A> { +impl<'a, C, A> CustomchannelMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1554,7 +1550,7 @@ impl<'a, C, NC, A> CustomchannelMethods<'a, C, NC, A> { /// /// * `adClientId` - Ad client from which to get the custom channel. /// * `customChannelId` - Custom channel to get. - pub fn get(&self, ad_client_id: &str, custom_channel_id: &str) -> CustomchannelGetCall<'a, C, NC, A> { + pub fn get(&self, ad_client_id: &str, custom_channel_id: &str) -> CustomchannelGetCall<'a, C, A> { CustomchannelGetCall { hub: self.hub, _ad_client_id: ad_client_id.to_string(), @@ -1573,7 +1569,7 @@ impl<'a, C, NC, A> CustomchannelMethods<'a, C, NC, A> { /// /// * `adClientId` - Ad client from which to delete the custom channel. /// * `customChannelId` - Custom channel to delete. - pub fn delete(&self, ad_client_id: &str, custom_channel_id: &str) -> CustomchannelDeleteCall<'a, C, NC, A> { + pub fn delete(&self, ad_client_id: &str, custom_channel_id: &str) -> CustomchannelDeleteCall<'a, C, A> { CustomchannelDeleteCall { hub: self.hub, _ad_client_id: ad_client_id.to_string(), @@ -1592,7 +1588,7 @@ impl<'a, C, NC, A> CustomchannelMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `adClientId` - Ad client in which the custom channel will be updated. - pub fn update(&self, request: &CustomChannel, ad_client_id: &str) -> CustomchannelUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &CustomChannel, ad_client_id: &str) -> CustomchannelUpdateCall<'a, C, A> { CustomchannelUpdateCall { hub: self.hub, _request: request.clone(), @@ -1610,7 +1606,7 @@ impl<'a, C, NC, A> CustomchannelMethods<'a, C, NC, A> { /// # Arguments /// /// * `adClientId` - Ad client for which to list custom channels. - pub fn list(&self, ad_client_id: &str) -> CustomchannelListCall<'a, C, NC, A> { + pub fn list(&self, ad_client_id: &str) -> CustomchannelListCall<'a, C, A> { CustomchannelListCall { hub: self.hub, _ad_client_id: ad_client_id.to_string(), @@ -1631,7 +1627,7 @@ impl<'a, C, NC, A> CustomchannelMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `adClientId` - Ad client in which the custom channel will be updated. /// * `customChannelId` - Custom channel to get. - pub fn patch(&self, request: &CustomChannel, ad_client_id: &str, custom_channel_id: &str) -> CustomchannelPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &CustomChannel, ad_client_id: &str, custom_channel_id: &str) -> CustomchannelPatchCall<'a, C, A> { CustomchannelPatchCall { hub: self.hub, _request: request.clone(), @@ -1651,7 +1647,7 @@ impl<'a, C, NC, A> CustomchannelMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `adClientId` - Ad client to which the new custom channel will be added. - pub fn insert(&self, request: &CustomChannel, ad_client_id: &str) -> CustomchannelInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &CustomChannel, ad_client_id: &str) -> CustomchannelInsertCall<'a, C, A> { CustomchannelInsertCall { hub: self.hub, _request: request.clone(), @@ -1707,10 +1703,10 @@ impl<'a, C, NC, A> CustomchannelMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct UrlchannelInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlchannelInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _request: UrlChannel, _ad_client_id: String, _delegate: Option<&'a mut Delegate>, @@ -1718,9 +1714,9 @@ pub struct UrlchannelInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UrlchannelInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UrlchannelInsertCall<'a, C, A> {} -impl<'a, C, NC, A> UrlchannelInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UrlchannelInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1859,7 +1855,7 @@ impl<'a, C, NC, A> UrlchannelInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &UrlChannel) -> UrlchannelInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &UrlChannel) -> UrlchannelInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1869,7 +1865,7 @@ impl<'a, C, NC, A> UrlchannelInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Ad client to which the new URL channel will be added. - pub fn ad_client_id(mut self, new_value: &str) -> UrlchannelInsertCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> UrlchannelInsertCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -1880,7 +1876,7 @@ impl<'a, C, NC, A> UrlchannelInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlchannelInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlchannelInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1901,7 +1897,7 @@ impl<'a, C, NC, A> UrlchannelInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UrlchannelInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UrlchannelInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1918,7 +1914,7 @@ impl<'a, C, NC, A> UrlchannelInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UrlchannelInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UrlchannelInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1956,10 +1952,10 @@ impl<'a, C, NC, A> UrlchannelInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct UrlchannelDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlchannelDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _ad_client_id: String, _url_channel_id: String, _delegate: Option<&'a mut Delegate>, @@ -1967,9 +1963,9 @@ pub struct UrlchannelDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UrlchannelDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UrlchannelDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> UrlchannelDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UrlchannelDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2102,7 +2098,7 @@ impl<'a, C, NC, A> UrlchannelDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Ad client from which to delete the URL channel. - pub fn ad_client_id(mut self, new_value: &str) -> UrlchannelDeleteCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> UrlchannelDeleteCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -2112,7 +2108,7 @@ impl<'a, C, NC, A> UrlchannelDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// URL channel to delete. - pub fn url_channel_id(mut self, new_value: &str) -> UrlchannelDeleteCall<'a, C, NC, A> { + pub fn url_channel_id(mut self, new_value: &str) -> UrlchannelDeleteCall<'a, C, A> { self._url_channel_id = new_value.to_string(); self } @@ -2123,7 +2119,7 @@ impl<'a, C, NC, A> UrlchannelDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlchannelDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlchannelDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2144,7 +2140,7 @@ impl<'a, C, NC, A> UrlchannelDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UrlchannelDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UrlchannelDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2161,7 +2157,7 @@ impl<'a, C, NC, A> UrlchannelDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UrlchannelDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UrlchannelDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2201,10 +2197,10 @@ impl<'a, C, NC, A> UrlchannelDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct UrlchannelListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlchannelListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _ad_client_id: String, _page_token: Option, _max_results: Option, @@ -2213,9 +2209,9 @@ pub struct UrlchannelListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UrlchannelListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UrlchannelListCall<'a, C, A> {} -impl<'a, C, NC, A> UrlchannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UrlchannelListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2353,7 +2349,7 @@ impl<'a, C, NC, A> UrlchannelListCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Ad client for which to list URL channels. - pub fn ad_client_id(mut self, new_value: &str) -> UrlchannelListCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> UrlchannelListCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -2361,7 +2357,7 @@ impl<'a, C, NC, A> UrlchannelListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// A continuation token, used to page through URL channels. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> UrlchannelListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> UrlchannelListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2369,7 +2365,7 @@ impl<'a, C, NC, A> UrlchannelListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The maximum number of URL channels to include in the response, used for paging. - pub fn max_results(mut self, new_value: u32) -> UrlchannelListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> UrlchannelListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2380,7 +2376,7 @@ impl<'a, C, NC, A> UrlchannelListCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlchannelListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlchannelListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2401,7 +2397,7 @@ impl<'a, C, NC, A> UrlchannelListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UrlchannelListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UrlchannelListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2418,7 +2414,7 @@ impl<'a, C, NC, A> UrlchannelListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UrlchannelListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UrlchannelListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2458,10 +2454,10 @@ impl<'a, C, NC, A> UrlchannelListCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct AdclientListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdclientListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _page_token: Option, _max_results: Option, _delegate: Option<&'a mut Delegate>, @@ -2469,9 +2465,9 @@ pub struct AdclientListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AdclientListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdclientListCall<'a, C, A> {} -impl<'a, C, NC, A> AdclientListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdclientListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2582,7 +2578,7 @@ impl<'a, C, NC, A> AdclientListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// A continuation token, used to page through ad clients. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> AdclientListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AdclientListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2590,7 +2586,7 @@ impl<'a, C, NC, A> AdclientListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The maximum number of ad clients to include in the response, used for paging. - pub fn max_results(mut self, new_value: u32) -> AdclientListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> AdclientListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2601,7 +2597,7 @@ impl<'a, C, NC, A> AdclientListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdclientListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdclientListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2622,7 +2618,7 @@ impl<'a, C, NC, A> AdclientListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdclientListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdclientListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2639,7 +2635,7 @@ impl<'a, C, NC, A> AdclientListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AdclientListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AdclientListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2677,19 +2673,19 @@ impl<'a, C, NC, A> AdclientListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct AdclientGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdclientGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _ad_client_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AdclientGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdclientGetCall<'a, C, A> {} -impl<'a, C, NC, A> AdclientGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdclientGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2821,7 +2817,7 @@ impl<'a, C, NC, A> AdclientGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Ad client to get. - pub fn ad_client_id(mut self, new_value: &str) -> AdclientGetCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AdclientGetCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -2832,7 +2828,7 @@ impl<'a, C, NC, A> AdclientGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdclientGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdclientGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2853,7 +2849,7 @@ impl<'a, C, NC, A> AdclientGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdclientGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdclientGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2870,7 +2866,7 @@ impl<'a, C, NC, A> AdclientGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AdclientGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AdclientGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2910,10 +2906,10 @@ impl<'a, C, NC, A> AdclientGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct AssociationsessionStartCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AssociationsessionStartCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _product_code: Vec, _website_url: String, _website_locale: Option, @@ -2923,9 +2919,9 @@ pub struct AssociationsessionStartCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AssociationsessionStartCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AssociationsessionStartCall<'a, C, A> {} -impl<'a, C, NC, A> AssociationsessionStartCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AssociationsessionStartCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3047,7 +3043,7 @@ impl<'a, C, NC, A> AssociationsessionStartCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Products to associate with the user. - pub fn add_product_code(mut self, new_value: &str) -> AssociationsessionStartCall<'a, C, NC, A> { + pub fn add_product_code(mut self, new_value: &str) -> AssociationsessionStartCall<'a, C, A> { self._product_code.push(new_value.to_string()); self } @@ -3057,7 +3053,7 @@ impl<'a, C, NC, A> AssociationsessionStartCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The URL of the user's hosted website. - pub fn website_url(mut self, new_value: &str) -> AssociationsessionStartCall<'a, C, NC, A> { + pub fn website_url(mut self, new_value: &str) -> AssociationsessionStartCall<'a, C, A> { self._website_url = new_value.to_string(); self } @@ -3065,7 +3061,7 @@ impl<'a, C, NC, A> AssociationsessionStartCall<'a, C, NC, A> where NC: hyper::ne /// /// /// The locale of the user's hosted website. - pub fn website_locale(mut self, new_value: &str) -> AssociationsessionStartCall<'a, C, NC, A> { + pub fn website_locale(mut self, new_value: &str) -> AssociationsessionStartCall<'a, C, A> { self._website_locale = Some(new_value.to_string()); self } @@ -3073,7 +3069,7 @@ impl<'a, C, NC, A> AssociationsessionStartCall<'a, C, NC, A> where NC: hyper::ne /// /// /// The preferred locale of the user. - pub fn user_locale(mut self, new_value: &str) -> AssociationsessionStartCall<'a, C, NC, A> { + pub fn user_locale(mut self, new_value: &str) -> AssociationsessionStartCall<'a, C, A> { self._user_locale = Some(new_value.to_string()); self } @@ -3084,7 +3080,7 @@ impl<'a, C, NC, A> AssociationsessionStartCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AssociationsessionStartCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AssociationsessionStartCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3105,7 +3101,7 @@ impl<'a, C, NC, A> AssociationsessionStartCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AssociationsessionStartCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AssociationsessionStartCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3122,7 +3118,7 @@ impl<'a, C, NC, A> AssociationsessionStartCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AssociationsessionStartCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AssociationsessionStartCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3160,19 +3156,19 @@ impl<'a, C, NC, A> AssociationsessionStartCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct AssociationsessionVerifyCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AssociationsessionVerifyCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _token: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AssociationsessionVerifyCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AssociationsessionVerifyCall<'a, C, A> {} -impl<'a, C, NC, A> AssociationsessionVerifyCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AssociationsessionVerifyCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3280,7 +3276,7 @@ impl<'a, C, NC, A> AssociationsessionVerifyCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The token returned to the association callback URL. - pub fn token(mut self, new_value: &str) -> AssociationsessionVerifyCall<'a, C, NC, A> { + pub fn token(mut self, new_value: &str) -> AssociationsessionVerifyCall<'a, C, A> { self._token = new_value.to_string(); self } @@ -3291,7 +3287,7 @@ impl<'a, C, NC, A> AssociationsessionVerifyCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AssociationsessionVerifyCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AssociationsessionVerifyCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3312,7 +3308,7 @@ impl<'a, C, NC, A> AssociationsessionVerifyCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AssociationsessionVerifyCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AssociationsessionVerifyCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3329,7 +3325,7 @@ impl<'a, C, NC, A> AssociationsessionVerifyCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AssociationsessionVerifyCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AssociationsessionVerifyCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3374,10 +3370,10 @@ impl<'a, C, NC, A> AssociationsessionVerifyCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct ReportGenerateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportGenerateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _start_date: String, _end_date: String, _start_index: Option, @@ -3392,9 +3388,9 @@ pub struct ReportGenerateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReportGenerateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReportGenerateCall<'a, C, A> {} -impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReportGenerateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3540,7 +3536,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Start of the date range to report on in "YYYY-MM-DD" format, inclusive. - pub fn start_date(mut self, new_value: &str) -> ReportGenerateCall<'a, C, NC, A> { + pub fn start_date(mut self, new_value: &str) -> ReportGenerateCall<'a, C, A> { self._start_date = new_value.to_string(); self } @@ -3550,7 +3546,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// End of the date range to report on in "YYYY-MM-DD" format, inclusive. - pub fn end_date(mut self, new_value: &str) -> ReportGenerateCall<'a, C, NC, A> { + pub fn end_date(mut self, new_value: &str) -> ReportGenerateCall<'a, C, A> { self._end_date = new_value.to_string(); self } @@ -3558,7 +3554,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Index of the first row of report data to return. - pub fn start_index(mut self, new_value: u32) -> ReportGenerateCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: u32) -> ReportGenerateCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -3567,7 +3563,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The name of a dimension or metric to sort the resulting report on, optionally prefixed with "+" to sort ascending or "-" to sort descending. If no prefix is specified, the column is sorted ascending. - pub fn add_sort(mut self, new_value: &str) -> ReportGenerateCall<'a, C, NC, A> { + pub fn add_sort(mut self, new_value: &str) -> ReportGenerateCall<'a, C, A> { self._sort.push(new_value.to_string()); self } @@ -3576,7 +3572,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Numeric columns to include in the report. - pub fn add_metric(mut self, new_value: &str) -> ReportGenerateCall<'a, C, NC, A> { + pub fn add_metric(mut self, new_value: &str) -> ReportGenerateCall<'a, C, A> { self._metric.push(new_value.to_string()); self } @@ -3584,7 +3580,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The maximum number of rows of report data to return. - pub fn max_results(mut self, new_value: u32) -> ReportGenerateCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> ReportGenerateCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -3592,7 +3588,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Optional locale to use for translating report output to a local language. Defaults to "en_US" if not specified. - pub fn locale(mut self, new_value: &str) -> ReportGenerateCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> ReportGenerateCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -3601,7 +3597,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Filters to be run on the report. - pub fn add_filter(mut self, new_value: &str) -> ReportGenerateCall<'a, C, NC, A> { + pub fn add_filter(mut self, new_value: &str) -> ReportGenerateCall<'a, C, A> { self._filter.push(new_value.to_string()); self } @@ -3610,7 +3606,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Dimensions to base the report on. - pub fn add_dimension(mut self, new_value: &str) -> ReportGenerateCall<'a, C, NC, A> { + pub fn add_dimension(mut self, new_value: &str) -> ReportGenerateCall<'a, C, A> { self._dimension.push(new_value.to_string()); self } @@ -3621,7 +3617,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportGenerateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportGenerateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3642,7 +3638,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReportGenerateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReportGenerateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3659,7 +3655,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReportGenerateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReportGenerateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3700,10 +3696,10 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct AccountAdunitListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountAdunitListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _account_id: String, _ad_client_id: String, _page_token: Option, @@ -3714,9 +3710,9 @@ pub struct AccountAdunitListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountAdunitListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountAdunitListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountAdunitListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountAdunitListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3858,7 +3854,7 @@ impl<'a, C, NC, A> AccountAdunitListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Account which contains the ad client. - pub fn account_id(mut self, new_value: &str) -> AccountAdunitListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountAdunitListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -3868,7 +3864,7 @@ impl<'a, C, NC, A> AccountAdunitListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Ad client for which to list ad units. - pub fn ad_client_id(mut self, new_value: &str) -> AccountAdunitListCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AccountAdunitListCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -3876,7 +3872,7 @@ impl<'a, C, NC, A> AccountAdunitListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// A continuation token, used to page through ad units. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> AccountAdunitListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AccountAdunitListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -3884,7 +3880,7 @@ impl<'a, C, NC, A> AccountAdunitListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The maximum number of ad units to include in the response, used for paging. - pub fn max_results(mut self, new_value: u32) -> AccountAdunitListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> AccountAdunitListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -3892,7 +3888,7 @@ impl<'a, C, NC, A> AccountAdunitListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Whether to include inactive ad units. Default: true. - pub fn include_inactive(mut self, new_value: bool) -> AccountAdunitListCall<'a, C, NC, A> { + pub fn include_inactive(mut self, new_value: bool) -> AccountAdunitListCall<'a, C, A> { self._include_inactive = Some(new_value); self } @@ -3903,7 +3899,7 @@ impl<'a, C, NC, A> AccountAdunitListCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdunitListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdunitListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3924,7 +3920,7 @@ impl<'a, C, NC, A> AccountAdunitListCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountAdunitListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountAdunitListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3941,7 +3937,7 @@ impl<'a, C, NC, A> AccountAdunitListCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountAdunitListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountAdunitListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3979,19 +3975,19 @@ impl<'a, C, NC, A> AccountAdunitListCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct AccountListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _filter_ad_client_id: Vec, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4106,7 +4102,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Ad clients to list accounts for. - pub fn add_filter_ad_client_id(mut self, new_value: &str) -> AccountListCall<'a, C, NC, A> { + pub fn add_filter_ad_client_id(mut self, new_value: &str) -> AccountListCall<'a, C, A> { self._filter_ad_client_id.push(new_value.to_string()); self } @@ -4117,7 +4113,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4138,7 +4134,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4155,7 +4151,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4194,10 +4190,10 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct AccountAdunitGetAdCodeCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountAdunitGetAdCodeCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _account_id: String, _ad_client_id: String, _ad_unit_id: String, @@ -4207,9 +4203,9 @@ pub struct AccountAdunitGetAdCodeCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountAdunitGetAdCodeCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountAdunitGetAdCodeCall<'a, C, A> {} -impl<'a, C, NC, A> AccountAdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountAdunitGetAdCodeCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4350,7 +4346,7 @@ impl<'a, C, NC, A> AccountAdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Account which contains the ad client. - pub fn account_id(mut self, new_value: &str) -> AccountAdunitGetAdCodeCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountAdunitGetAdCodeCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -4360,7 +4356,7 @@ impl<'a, C, NC, A> AccountAdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Ad client with contains the ad unit. - pub fn ad_client_id(mut self, new_value: &str) -> AccountAdunitGetAdCodeCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AccountAdunitGetAdCodeCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -4370,7 +4366,7 @@ impl<'a, C, NC, A> AccountAdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Ad unit to get the code for. - pub fn ad_unit_id(mut self, new_value: &str) -> AccountAdunitGetAdCodeCall<'a, C, NC, A> { + pub fn ad_unit_id(mut self, new_value: &str) -> AccountAdunitGetAdCodeCall<'a, C, A> { self._ad_unit_id = new_value.to_string(); self } @@ -4379,7 +4375,7 @@ impl<'a, C, NC, A> AccountAdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net /// /// /// Host custom channel to attach to the ad code. - pub fn add_host_custom_channel_id(mut self, new_value: &str) -> AccountAdunitGetAdCodeCall<'a, C, NC, A> { + pub fn add_host_custom_channel_id(mut self, new_value: &str) -> AccountAdunitGetAdCodeCall<'a, C, A> { self._host_custom_channel_id.push(new_value.to_string()); self } @@ -4390,7 +4386,7 @@ impl<'a, C, NC, A> AccountAdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdunitGetAdCodeCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdunitGetAdCodeCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4411,7 +4407,7 @@ impl<'a, C, NC, A> AccountAdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountAdunitGetAdCodeCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountAdunitGetAdCodeCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4428,7 +4424,7 @@ impl<'a, C, NC, A> AccountAdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountAdunitGetAdCodeCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountAdunitGetAdCodeCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4473,10 +4469,10 @@ impl<'a, C, NC, A> AccountAdunitGetAdCodeCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct AccountReportGenerateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountReportGenerateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _account_id: String, _start_date: String, _end_date: String, @@ -4492,9 +4488,9 @@ pub struct AccountReportGenerateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountReportGenerateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountReportGenerateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountReportGenerateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4665,7 +4661,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Hosted account upon which to report. - pub fn account_id(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -4675,7 +4671,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Start of the date range to report on in "YYYY-MM-DD" format, inclusive. - pub fn start_date(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn start_date(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._start_date = new_value.to_string(); self } @@ -4685,7 +4681,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// End of the date range to report on in "YYYY-MM-DD" format, inclusive. - pub fn end_date(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn end_date(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._end_date = new_value.to_string(); self } @@ -4693,7 +4689,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Index of the first row of report data to return. - pub fn start_index(mut self, new_value: u32) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: u32) -> AccountReportGenerateCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -4702,7 +4698,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// The name of a dimension or metric to sort the resulting report on, optionally prefixed with "+" to sort ascending or "-" to sort descending. If no prefix is specified, the column is sorted ascending. - pub fn add_sort(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn add_sort(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._sort.push(new_value.to_string()); self } @@ -4711,7 +4707,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Numeric columns to include in the report. - pub fn add_metric(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn add_metric(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._metric.push(new_value.to_string()); self } @@ -4719,7 +4715,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// The maximum number of rows of report data to return. - pub fn max_results(mut self, new_value: u32) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> AccountReportGenerateCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -4727,7 +4723,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Optional locale to use for translating report output to a local language. Defaults to "en_US" if not specified. - pub fn locale(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -4736,7 +4732,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Filters to be run on the report. - pub fn add_filter(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn add_filter(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._filter.push(new_value.to_string()); self } @@ -4745,7 +4741,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Dimensions to base the report on. - pub fn add_dimension(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn add_dimension(mut self, new_value: &str) -> AccountReportGenerateCall<'a, C, A> { self._dimension.push(new_value.to_string()); self } @@ -4756,7 +4752,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountReportGenerateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountReportGenerateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4777,7 +4773,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountReportGenerateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountReportGenerateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4794,7 +4790,7 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountReportGenerateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountReportGenerateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4832,10 +4828,10 @@ impl<'a, C, NC, A> AccountReportGenerateCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct AccountAdunitDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountAdunitDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _account_id: String, _ad_client_id: String, _ad_unit_id: String, @@ -4844,9 +4840,9 @@ pub struct AccountAdunitDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountAdunitDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountAdunitDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> AccountAdunitDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountAdunitDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4980,7 +4976,7 @@ impl<'a, C, NC, A> AccountAdunitDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Account which contains the ad unit. - pub fn account_id(mut self, new_value: &str) -> AccountAdunitDeleteCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountAdunitDeleteCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -4990,7 +4986,7 @@ impl<'a, C, NC, A> AccountAdunitDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Ad client for which to get ad unit. - pub fn ad_client_id(mut self, new_value: &str) -> AccountAdunitDeleteCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AccountAdunitDeleteCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -5000,7 +4996,7 @@ impl<'a, C, NC, A> AccountAdunitDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Ad unit to delete. - pub fn ad_unit_id(mut self, new_value: &str) -> AccountAdunitDeleteCall<'a, C, NC, A> { + pub fn ad_unit_id(mut self, new_value: &str) -> AccountAdunitDeleteCall<'a, C, A> { self._ad_unit_id = new_value.to_string(); self } @@ -5011,7 +5007,7 @@ impl<'a, C, NC, A> AccountAdunitDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdunitDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdunitDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5032,7 +5028,7 @@ impl<'a, C, NC, A> AccountAdunitDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountAdunitDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountAdunitDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5049,7 +5045,7 @@ impl<'a, C, NC, A> AccountAdunitDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountAdunitDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountAdunitDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5089,10 +5085,10 @@ impl<'a, C, NC, A> AccountAdunitDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct AccountAdclientListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountAdclientListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _account_id: String, _page_token: Option, _max_results: Option, @@ -5101,9 +5097,9 @@ pub struct AccountAdclientListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountAdclientListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountAdclientListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountAdclientListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5241,7 +5237,7 @@ impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Account for which to list ad clients. - pub fn account_id(mut self, new_value: &str) -> AccountAdclientListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountAdclientListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -5249,7 +5245,7 @@ impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// A continuation token, used to page through ad clients. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> AccountAdclientListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AccountAdclientListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -5257,7 +5253,7 @@ impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The maximum number of ad clients to include in the response, used for paging. - pub fn max_results(mut self, new_value: u32) -> AccountAdclientListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> AccountAdclientListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -5268,7 +5264,7 @@ impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdclientListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdclientListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5289,7 +5285,7 @@ impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountAdclientListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountAdclientListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5306,7 +5302,7 @@ impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountAdclientListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountAdclientListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5350,10 +5346,10 @@ impl<'a, C, NC, A> AccountAdclientListCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct AccountAdunitPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountAdunitPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _request: AdUnit, _account_id: String, _ad_client_id: String, @@ -5363,9 +5359,9 @@ pub struct AccountAdunitPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountAdunitPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountAdunitPatchCall<'a, C, A> {} -impl<'a, C, NC, A> AccountAdunitPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountAdunitPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5506,7 +5502,7 @@ impl<'a, C, NC, A> AccountAdunitPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AdUnit) -> AccountAdunitPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AdUnit) -> AccountAdunitPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5516,7 +5512,7 @@ impl<'a, C, NC, A> AccountAdunitPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Account which contains the ad client. - pub fn account_id(mut self, new_value: &str) -> AccountAdunitPatchCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountAdunitPatchCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -5526,7 +5522,7 @@ impl<'a, C, NC, A> AccountAdunitPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Ad client which contains the ad unit. - pub fn ad_client_id(mut self, new_value: &str) -> AccountAdunitPatchCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AccountAdunitPatchCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -5536,7 +5532,7 @@ impl<'a, C, NC, A> AccountAdunitPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Ad unit to get. - pub fn ad_unit_id(mut self, new_value: &str) -> AccountAdunitPatchCall<'a, C, NC, A> { + pub fn ad_unit_id(mut self, new_value: &str) -> AccountAdunitPatchCall<'a, C, A> { self._ad_unit_id = new_value.to_string(); self } @@ -5547,7 +5543,7 @@ impl<'a, C, NC, A> AccountAdunitPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdunitPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdunitPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5568,7 +5564,7 @@ impl<'a, C, NC, A> AccountAdunitPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountAdunitPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountAdunitPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5585,7 +5581,7 @@ impl<'a, C, NC, A> AccountAdunitPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountAdunitPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountAdunitPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5623,10 +5619,10 @@ impl<'a, C, NC, A> AccountAdunitPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct AccountAdclientGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountAdclientGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _account_id: String, _ad_client_id: String, _delegate: Option<&'a mut Delegate>, @@ -5634,9 +5630,9 @@ pub struct AccountAdclientGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountAdclientGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountAdclientGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountAdclientGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountAdclientGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5769,7 +5765,7 @@ impl<'a, C, NC, A> AccountAdclientGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Account which contains the ad client. - pub fn account_id(mut self, new_value: &str) -> AccountAdclientGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountAdclientGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -5779,7 +5775,7 @@ impl<'a, C, NC, A> AccountAdclientGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Ad client to get. - pub fn ad_client_id(mut self, new_value: &str) -> AccountAdclientGetCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AccountAdclientGetCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -5790,7 +5786,7 @@ impl<'a, C, NC, A> AccountAdclientGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdclientGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdclientGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5811,7 +5807,7 @@ impl<'a, C, NC, A> AccountAdclientGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountAdclientGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountAdclientGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5828,7 +5824,7 @@ impl<'a, C, NC, A> AccountAdclientGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountAdclientGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountAdclientGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5866,19 +5862,19 @@ impl<'a, C, NC, A> AccountAdclientGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct AccountGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _account_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6010,7 +6006,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Account to get information about. - pub fn account_id(mut self, new_value: &str) -> AccountGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -6021,7 +6017,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6042,7 +6038,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6059,7 +6055,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6103,10 +6099,10 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct AccountAdunitInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountAdunitInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _request: AdUnit, _account_id: String, _ad_client_id: String, @@ -6115,9 +6111,9 @@ pub struct AccountAdunitInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountAdunitInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountAdunitInsertCall<'a, C, A> {} -impl<'a, C, NC, A> AccountAdunitInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountAdunitInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6257,7 +6253,7 @@ impl<'a, C, NC, A> AccountAdunitInsertCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AdUnit) -> AccountAdunitInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AdUnit) -> AccountAdunitInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6267,7 +6263,7 @@ impl<'a, C, NC, A> AccountAdunitInsertCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Account which will contain the ad unit. - pub fn account_id(mut self, new_value: &str) -> AccountAdunitInsertCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountAdunitInsertCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -6277,7 +6273,7 @@ impl<'a, C, NC, A> AccountAdunitInsertCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Ad client into which to insert the ad unit. - pub fn ad_client_id(mut self, new_value: &str) -> AccountAdunitInsertCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AccountAdunitInsertCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -6288,7 +6284,7 @@ impl<'a, C, NC, A> AccountAdunitInsertCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdunitInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdunitInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6309,7 +6305,7 @@ impl<'a, C, NC, A> AccountAdunitInsertCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountAdunitInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountAdunitInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6326,7 +6322,7 @@ impl<'a, C, NC, A> AccountAdunitInsertCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountAdunitInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountAdunitInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6364,10 +6360,10 @@ impl<'a, C, NC, A> AccountAdunitInsertCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct AccountAdunitGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountAdunitGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _account_id: String, _ad_client_id: String, _ad_unit_id: String, @@ -6376,9 +6372,9 @@ pub struct AccountAdunitGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountAdunitGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountAdunitGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountAdunitGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountAdunitGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6512,7 +6508,7 @@ impl<'a, C, NC, A> AccountAdunitGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Account which contains the ad unit. - pub fn account_id(mut self, new_value: &str) -> AccountAdunitGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountAdunitGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -6522,7 +6518,7 @@ impl<'a, C, NC, A> AccountAdunitGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Ad client for which to get ad unit. - pub fn ad_client_id(mut self, new_value: &str) -> AccountAdunitGetCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AccountAdunitGetCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -6532,7 +6528,7 @@ impl<'a, C, NC, A> AccountAdunitGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Ad unit to get. - pub fn ad_unit_id(mut self, new_value: &str) -> AccountAdunitGetCall<'a, C, NC, A> { + pub fn ad_unit_id(mut self, new_value: &str) -> AccountAdunitGetCall<'a, C, A> { self._ad_unit_id = new_value.to_string(); self } @@ -6543,7 +6539,7 @@ impl<'a, C, NC, A> AccountAdunitGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdunitGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdunitGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6564,7 +6560,7 @@ impl<'a, C, NC, A> AccountAdunitGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountAdunitGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountAdunitGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6581,7 +6577,7 @@ impl<'a, C, NC, A> AccountAdunitGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountAdunitGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountAdunitGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6625,10 +6621,10 @@ impl<'a, C, NC, A> AccountAdunitGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct AccountAdunitUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountAdunitUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _request: AdUnit, _account_id: String, _ad_client_id: String, @@ -6637,9 +6633,9 @@ pub struct AccountAdunitUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountAdunitUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountAdunitUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountAdunitUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountAdunitUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6779,7 +6775,7 @@ impl<'a, C, NC, A> AccountAdunitUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AdUnit) -> AccountAdunitUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AdUnit) -> AccountAdunitUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6789,7 +6785,7 @@ impl<'a, C, NC, A> AccountAdunitUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Account which contains the ad client. - pub fn account_id(mut self, new_value: &str) -> AccountAdunitUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountAdunitUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -6799,7 +6795,7 @@ impl<'a, C, NC, A> AccountAdunitUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Ad client which contains the ad unit. - pub fn ad_client_id(mut self, new_value: &str) -> AccountAdunitUpdateCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> AccountAdunitUpdateCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -6810,7 +6806,7 @@ impl<'a, C, NC, A> AccountAdunitUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdunitUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAdunitUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6831,7 +6827,7 @@ impl<'a, C, NC, A> AccountAdunitUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountAdunitUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountAdunitUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6848,7 +6844,7 @@ impl<'a, C, NC, A> AccountAdunitUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountAdunitUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountAdunitUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6886,10 +6882,10 @@ impl<'a, C, NC, A> AccountAdunitUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct CustomchannelGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CustomchannelGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _ad_client_id: String, _custom_channel_id: String, _delegate: Option<&'a mut Delegate>, @@ -6897,9 +6893,9 @@ pub struct CustomchannelGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CustomchannelGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CustomchannelGetCall<'a, C, A> {} -impl<'a, C, NC, A> CustomchannelGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CustomchannelGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7032,7 +7028,7 @@ impl<'a, C, NC, A> CustomchannelGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Ad client from which to get the custom channel. - pub fn ad_client_id(mut self, new_value: &str) -> CustomchannelGetCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> CustomchannelGetCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -7042,7 +7038,7 @@ impl<'a, C, NC, A> CustomchannelGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Custom channel to get. - pub fn custom_channel_id(mut self, new_value: &str) -> CustomchannelGetCall<'a, C, NC, A> { + pub fn custom_channel_id(mut self, new_value: &str) -> CustomchannelGetCall<'a, C, A> { self._custom_channel_id = new_value.to_string(); self } @@ -7053,7 +7049,7 @@ impl<'a, C, NC, A> CustomchannelGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomchannelGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomchannelGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7074,7 +7070,7 @@ impl<'a, C, NC, A> CustomchannelGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CustomchannelGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CustomchannelGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7091,7 +7087,7 @@ impl<'a, C, NC, A> CustomchannelGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CustomchannelGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CustomchannelGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7129,10 +7125,10 @@ impl<'a, C, NC, A> CustomchannelGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct CustomchannelDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CustomchannelDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _ad_client_id: String, _custom_channel_id: String, _delegate: Option<&'a mut Delegate>, @@ -7140,9 +7136,9 @@ pub struct CustomchannelDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CustomchannelDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CustomchannelDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> CustomchannelDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CustomchannelDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7275,7 +7271,7 @@ impl<'a, C, NC, A> CustomchannelDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Ad client from which to delete the custom channel. - pub fn ad_client_id(mut self, new_value: &str) -> CustomchannelDeleteCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> CustomchannelDeleteCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -7285,7 +7281,7 @@ impl<'a, C, NC, A> CustomchannelDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Custom channel to delete. - pub fn custom_channel_id(mut self, new_value: &str) -> CustomchannelDeleteCall<'a, C, NC, A> { + pub fn custom_channel_id(mut self, new_value: &str) -> CustomchannelDeleteCall<'a, C, A> { self._custom_channel_id = new_value.to_string(); self } @@ -7296,7 +7292,7 @@ impl<'a, C, NC, A> CustomchannelDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomchannelDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomchannelDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7317,7 +7313,7 @@ impl<'a, C, NC, A> CustomchannelDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CustomchannelDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CustomchannelDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7334,7 +7330,7 @@ impl<'a, C, NC, A> CustomchannelDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CustomchannelDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CustomchannelDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7378,10 +7374,10 @@ impl<'a, C, NC, A> CustomchannelDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct CustomchannelUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CustomchannelUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _request: CustomChannel, _ad_client_id: String, _delegate: Option<&'a mut Delegate>, @@ -7389,9 +7385,9 @@ pub struct CustomchannelUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CustomchannelUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CustomchannelUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> CustomchannelUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CustomchannelUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7530,7 +7526,7 @@ impl<'a, C, NC, A> CustomchannelUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CustomChannel) -> CustomchannelUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CustomChannel) -> CustomchannelUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7540,7 +7536,7 @@ impl<'a, C, NC, A> CustomchannelUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Ad client in which the custom channel will be updated. - pub fn ad_client_id(mut self, new_value: &str) -> CustomchannelUpdateCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> CustomchannelUpdateCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -7551,7 +7547,7 @@ impl<'a, C, NC, A> CustomchannelUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomchannelUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomchannelUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7572,7 +7568,7 @@ impl<'a, C, NC, A> CustomchannelUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CustomchannelUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CustomchannelUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7589,7 +7585,7 @@ impl<'a, C, NC, A> CustomchannelUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CustomchannelUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CustomchannelUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7629,10 +7625,10 @@ impl<'a, C, NC, A> CustomchannelUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct CustomchannelListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CustomchannelListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _ad_client_id: String, _page_token: Option, _max_results: Option, @@ -7641,9 +7637,9 @@ pub struct CustomchannelListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CustomchannelListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CustomchannelListCall<'a, C, A> {} -impl<'a, C, NC, A> CustomchannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CustomchannelListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7781,7 +7777,7 @@ impl<'a, C, NC, A> CustomchannelListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Ad client for which to list custom channels. - pub fn ad_client_id(mut self, new_value: &str) -> CustomchannelListCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> CustomchannelListCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -7789,7 +7785,7 @@ impl<'a, C, NC, A> CustomchannelListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// A continuation token, used to page through custom channels. To retrieve the next page, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> CustomchannelListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> CustomchannelListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -7797,7 +7793,7 @@ impl<'a, C, NC, A> CustomchannelListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The maximum number of custom channels to include in the response, used for paging. - pub fn max_results(mut self, new_value: u32) -> CustomchannelListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> CustomchannelListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -7808,7 +7804,7 @@ impl<'a, C, NC, A> CustomchannelListCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomchannelListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomchannelListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7829,7 +7825,7 @@ impl<'a, C, NC, A> CustomchannelListCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CustomchannelListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CustomchannelListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7846,7 +7842,7 @@ impl<'a, C, NC, A> CustomchannelListCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CustomchannelListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CustomchannelListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7890,10 +7886,10 @@ impl<'a, C, NC, A> CustomchannelListCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct CustomchannelPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CustomchannelPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _request: CustomChannel, _ad_client_id: String, _custom_channel_id: String, @@ -7902,9 +7898,9 @@ pub struct CustomchannelPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CustomchannelPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CustomchannelPatchCall<'a, C, A> {} -impl<'a, C, NC, A> CustomchannelPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CustomchannelPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8044,7 +8040,7 @@ impl<'a, C, NC, A> CustomchannelPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CustomChannel) -> CustomchannelPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CustomChannel) -> CustomchannelPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8054,7 +8050,7 @@ impl<'a, C, NC, A> CustomchannelPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Ad client in which the custom channel will be updated. - pub fn ad_client_id(mut self, new_value: &str) -> CustomchannelPatchCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> CustomchannelPatchCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -8064,7 +8060,7 @@ impl<'a, C, NC, A> CustomchannelPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Custom channel to get. - pub fn custom_channel_id(mut self, new_value: &str) -> CustomchannelPatchCall<'a, C, NC, A> { + pub fn custom_channel_id(mut self, new_value: &str) -> CustomchannelPatchCall<'a, C, A> { self._custom_channel_id = new_value.to_string(); self } @@ -8075,7 +8071,7 @@ impl<'a, C, NC, A> CustomchannelPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomchannelPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomchannelPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8096,7 +8092,7 @@ impl<'a, C, NC, A> CustomchannelPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CustomchannelPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CustomchannelPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8113,7 +8109,7 @@ impl<'a, C, NC, A> CustomchannelPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CustomchannelPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CustomchannelPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8157,10 +8153,10 @@ impl<'a, C, NC, A> CustomchannelPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct CustomchannelInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CustomchannelInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AdSenseHost, + hub: &'a AdSenseHost, _request: CustomChannel, _ad_client_id: String, _delegate: Option<&'a mut Delegate>, @@ -8168,9 +8164,9 @@ pub struct CustomchannelInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CustomchannelInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CustomchannelInsertCall<'a, C, A> {} -impl<'a, C, NC, A> CustomchannelInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CustomchannelInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8309,7 +8305,7 @@ impl<'a, C, NC, A> CustomchannelInsertCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CustomChannel) -> CustomchannelInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CustomChannel) -> CustomchannelInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8319,7 +8315,7 @@ impl<'a, C, NC, A> CustomchannelInsertCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Ad client to which the new custom channel will be added. - pub fn ad_client_id(mut self, new_value: &str) -> CustomchannelInsertCall<'a, C, NC, A> { + pub fn ad_client_id(mut self, new_value: &str) -> CustomchannelInsertCall<'a, C, A> { self._ad_client_id = new_value.to_string(); self } @@ -8330,7 +8326,7 @@ impl<'a, C, NC, A> CustomchannelInsertCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomchannelInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomchannelInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8351,7 +8347,7 @@ impl<'a, C, NC, A> CustomchannelInsertCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CustomchannelInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CustomchannelInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8368,7 +8364,7 @@ impl<'a, C, NC, A> CustomchannelInsertCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CustomchannelInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CustomchannelInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/analytics3/Cargo.toml b/gen/analytics3/Cargo.toml index 645708898f5..e9e9fc8f97c 100644 --- a/gen/analytics3/Cargo.toml +++ b/gen/analytics3/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-analytics3" -version = "0.1.4+20150308" +version = "0.1.5+20150308" authors = ["Sebastian Thiel "] description = "A complete library to interact with analytics (protocol v3)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/analytics3" homepage = "https://developers.google.com/analytics/" -documentation = "http://byron.github.io/google-apis-rs/google-analytics3" +documentation = "http://byron.github.io/google-apis-rs/google_analytics3" license = "MIT" keywords = ["analytics", "google", "protocol", "web", "api"] diff --git a/gen/analytics3/README.md b/gen/analytics3/README.md index c20e2cf097d..03111a80559 100644 --- a/gen/analytics3/README.md +++ b/gen/analytics3/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-analytics3` library allows access to all features of the *Google analytics* service. -This documentation was generated from *analytics* crate version *0.1.4+20150308*, where *20150308* is the exact revision of the *analytics:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *analytics* crate version *0.1.5+20150308*, where *20150308* is the exact revision of the *analytics:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *analytics* *v3* API can be found at the [official documentation site](https://developers.google.com/analytics/). diff --git a/gen/analytics3/src/cmn.rs b/gen/analytics3/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/analytics3/src/cmn.rs +++ b/gen/analytics3/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/analytics3/src/lib.rs b/gen/analytics3/src/lib.rs index cbfebc2ef00..53d80af516e 100644 --- a/gen/analytics3/src/lib.rs +++ b/gen/analytics3/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *analytics* crate version *0.1.4+20150308*, where *20150308* is the exact revision of the *analytics:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *analytics* crate version *0.1.5+20150308*, where *20150308* is the exact revision of the *analytics:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *analytics* *v3* API can be found at the //! [official documentation site](https://developers.google.com/analytics/). @@ -209,7 +209,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -326,43 +325,40 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Analytics { +pub struct Analytics { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Analytics {} +impl<'a, C, A> Hub for Analytics {} -impl<'a, C, NC, A> Analytics - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Analytics + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Analytics { + pub fn new(client: C, authenticator: A) -> Analytics { Analytics { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn data(&'a self) -> DataMethods<'a, C, NC, A> { + pub fn data(&'a self) -> DataMethods<'a, C, A> { DataMethods { hub: &self } } - pub fn management(&'a self) -> ManagementMethods<'a, C, NC, A> { + pub fn management(&'a self) -> ManagementMethods<'a, C, A> { ManagementMethods { hub: &self } } - pub fn metadata(&'a self) -> MetadataMethods<'a, C, NC, A> { + pub fn metadata(&'a self) -> MetadataMethods<'a, C, A> { MetadataMethods { hub: &self } } - pub fn provisioning(&'a self) -> ProvisioningMethods<'a, C, NC, A> { + pub fn provisioning(&'a self) -> ProvisioningMethods<'a, C, A> { ProvisioningMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -3265,15 +3261,15 @@ impl Part for ProfileChildLink {} /// let rb = hub.management(); /// # } /// ``` -pub struct ManagementMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, } -impl<'a, C, NC, A> MethodsBuilder for ManagementMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ManagementMethods<'a, C, A> {} -impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { +impl<'a, C, A> ManagementMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3283,7 +3279,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `accountId` - Account ID to create the web property for. - pub fn webproperties_insert(&self, request: &Webproperty, account_id: &str) -> ManagementWebpropertyInsertCall<'a, C, NC, A> { + pub fn webproperties_insert(&self, request: &Webproperty, account_id: &str) -> ManagementWebpropertyInsertCall<'a, C, A> { ManagementWebpropertyInsertCall { hub: self.hub, _request: request.clone(), @@ -3303,7 +3299,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account ID to retrieve the goal for. /// * `webPropertyId` - Web property ID to retrieve the goal for. /// * `profileId` - View (Profile) ID to retrieve the goal for. - pub fn profiles_get(&self, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementProfileGetCall<'a, C, NC, A> { + pub fn profiles_get(&self, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementProfileGetCall<'a, C, A> { ManagementProfileGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -3318,7 +3314,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Lists all accounts to which the user has access. - pub fn accounts_list(&self) -> ManagementAccountListCall<'a, C, NC, A> { + pub fn accounts_list(&self) -> ManagementAccountListCall<'a, C, A> { ManagementAccountListCall { hub: self.hub, _start_index: Default::default(), @@ -3340,7 +3336,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `webPropertyId` - Web property Id to which profile filter link belongs /// * `profileId` - Profile ID to which filter link belongs /// * `linkId` - ID of the profile filter link to be updated. - pub fn profile_filter_links_patch(&self, request: &ProfileFilterLink, account_id: &str, web_property_id: &str, profile_id: &str, link_id: &str) -> ManagementProfileFilterLinkPatchCall<'a, C, NC, A> { + pub fn profile_filter_links_patch(&self, request: &ProfileFilterLink, account_id: &str, web_property_id: &str, profile_id: &str, link_id: &str) -> ManagementProfileFilterLinkPatchCall<'a, C, A> { ManagementProfileFilterLinkPatchCall { hub: self.hub, _request: request.clone(), @@ -3363,7 +3359,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account ID to delete the user link for. /// * `webPropertyId` - Web Property ID to delete the user link for. /// * `linkId` - Link ID to delete the user link for. - pub fn webproperty_user_links_delete(&self, account_id: &str, web_property_id: &str, link_id: &str) -> ManagementWebpropertyUserLinkDeleteCall<'a, C, NC, A> { + pub fn webproperty_user_links_delete(&self, account_id: &str, web_property_id: &str, link_id: &str) -> ManagementWebpropertyUserLinkDeleteCall<'a, C, A> { ManagementWebpropertyUserLinkDeleteCall { hub: self.hub, _account_id: account_id.to_string(), @@ -3385,7 +3381,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `webPropertyId` - Web Property ID to delete the user link for. /// * `profileId` - View (Profile) ID to delete the user link for. /// * `linkId` - Link ID to delete the user link for. - pub fn profile_user_links_delete(&self, account_id: &str, web_property_id: &str, profile_id: &str, link_id: &str) -> ManagementProfileUserLinkDeleteCall<'a, C, NC, A> { + pub fn profile_user_links_delete(&self, account_id: &str, web_property_id: &str, profile_id: &str, link_id: &str) -> ManagementProfileUserLinkDeleteCall<'a, C, A> { ManagementProfileUserLinkDeleteCall { hub: self.hub, _account_id: account_id.to_string(), @@ -3409,7 +3405,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `webPropertyId` - Web Property ID to update the user link for. /// * `profileId` - View (Profile ID) to update the user link for. /// * `linkId` - Link ID to update the user link for. - pub fn profile_user_links_update(&self, request: &EntityUserLink, account_id: &str, web_property_id: &str, profile_id: &str, link_id: &str) -> ManagementProfileUserLinkUpdateCall<'a, C, NC, A> { + pub fn profile_user_links_update(&self, request: &EntityUserLink, account_id: &str, web_property_id: &str, profile_id: &str, link_id: &str) -> ManagementProfileUserLinkUpdateCall<'a, C, A> { ManagementProfileUserLinkUpdateCall { hub: self.hub, _request: request.clone(), @@ -3431,7 +3427,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `accountId` - Account ID to create filter for. - pub fn filters_insert(&self, request: &Filter, account_id: &str) -> ManagementFilterInsertCall<'a, C, NC, A> { + pub fn filters_insert(&self, request: &Filter, account_id: &str) -> ManagementFilterInsertCall<'a, C, A> { ManagementFilterInsertCall { hub: self.hub, _request: request.clone(), @@ -3451,7 +3447,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - Account ID to update the account-user link for. /// * `linkId` - Link ID to update the account-user link for. - pub fn account_user_links_update(&self, request: &EntityUserLink, account_id: &str, link_id: &str) -> ManagementAccountUserLinkUpdateCall<'a, C, NC, A> { + pub fn account_user_links_update(&self, request: &EntityUserLink, account_id: &str, link_id: &str) -> ManagementAccountUserLinkUpdateCall<'a, C, A> { ManagementAccountUserLinkUpdateCall { hub: self.hub, _request: request.clone(), @@ -3472,7 +3468,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - Account ID to which the web property belongs /// * `webPropertyId` - Web property ID - pub fn webproperties_update(&self, request: &Webproperty, account_id: &str, web_property_id: &str) -> ManagementWebpropertyUpdateCall<'a, C, NC, A> { + pub fn webproperties_update(&self, request: &Webproperty, account_id: &str, web_property_id: &str) -> ManagementWebpropertyUpdateCall<'a, C, A> { ManagementWebpropertyUpdateCall { hub: self.hub, _request: request.clone(), @@ -3494,7 +3490,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account ID to update the account-user link for. /// * `webPropertyId` - Web property ID to update the account-user link for. /// * `linkId` - Link ID to update the account-user link for. - pub fn webproperty_user_links_update(&self, request: &EntityUserLink, account_id: &str, web_property_id: &str, link_id: &str) -> ManagementWebpropertyUserLinkUpdateCall<'a, C, NC, A> { + pub fn webproperty_user_links_update(&self, request: &EntityUserLink, account_id: &str, web_property_id: &str, link_id: &str) -> ManagementWebpropertyUserLinkUpdateCall<'a, C, A> { ManagementWebpropertyUserLinkUpdateCall { hub: self.hub, _request: request.clone(), @@ -3517,7 +3513,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account ID to create the unsampled report for. /// * `webPropertyId` - Web property ID to create the unsampled report for. /// * `profileId` - View (Profile) ID to create the unsampled report for. - pub fn unsampled_reports_insert(&self, request: &UnsampledReport, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementUnsampledReportInsertCall<'a, C, NC, A> { + pub fn unsampled_reports_insert(&self, request: &UnsampledReport, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementUnsampledReportInsertCall<'a, C, A> { ManagementUnsampledReportInsertCall { hub: self.hub, _request: request.clone(), @@ -3539,7 +3535,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account ID for the custom metric to retrieve. /// * `webPropertyId` - Web property ID for the custom metric to retrieve. /// * `customMetricId` - The ID of the custom metric to retrieve. - pub fn custom_metrics_get(&self, account_id: &str, web_property_id: &str, custom_metric_id: &str) -> ManagementCustomMetricGetCall<'a, C, NC, A> { + pub fn custom_metrics_get(&self, account_id: &str, web_property_id: &str, custom_metric_id: &str) -> ManagementCustomMetricGetCall<'a, C, A> { ManagementCustomMetricGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -3561,7 +3557,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `webPropertyId` - Web property Id for the upload to retrieve. /// * `customDataSourceId` - Custom data source Id for upload to retrieve. /// * `uploadId` - Upload Id to retrieve. - pub fn uploads_get(&self, account_id: &str, web_property_id: &str, custom_data_source_id: &str, upload_id: &str) -> ManagementUploadGetCall<'a, C, NC, A> { + pub fn uploads_get(&self, account_id: &str, web_property_id: &str, custom_data_source_id: &str, upload_id: &str) -> ManagementUploadGetCall<'a, C, A> { ManagementUploadGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -3583,7 +3579,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - ID of the account which the given web property belongs to. /// * `webPropertyId` - Web property ID to retrieve the AdWords link for. /// * `webPropertyAdWordsLinkId` - Web property-AdWords link ID. - pub fn web_property_ad_words_links_get(&self, account_id: &str, web_property_id: &str, web_property_ad_words_link_id: &str) -> ManagementWebPropertyAdWordsLinkGetCall<'a, C, NC, A> { + pub fn web_property_ad_words_links_get(&self, account_id: &str, web_property_id: &str, web_property_ad_words_link_id: &str) -> ManagementWebPropertyAdWordsLinkGetCall<'a, C, A> { ManagementWebPropertyAdWordsLinkGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -3603,7 +3599,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// /// * `accountId` - Account ID which the given web property belongs to. /// * `webPropertyId` - Web Property ID for the webProperty-user links to retrieve. Can either be a specific web property ID or '~all', which refers to all the web properties that user has access to. - pub fn webproperty_user_links_list(&self, account_id: &str, web_property_id: &str) -> ManagementWebpropertyUserLinkListCall<'a, C, NC, A> { + pub fn webproperty_user_links_list(&self, account_id: &str, web_property_id: &str) -> ManagementWebpropertyUserLinkListCall<'a, C, A> { ManagementWebpropertyUserLinkListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -3627,7 +3623,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `webPropertyId` - Web property Id to which profile filter link belongs /// * `profileId` - Profile ID to which filter link belongs /// * `linkId` - ID of the profile filter link to be updated. - pub fn profile_filter_links_update(&self, request: &ProfileFilterLink, account_id: &str, web_property_id: &str, profile_id: &str, link_id: &str) -> ManagementProfileFilterLinkUpdateCall<'a, C, NC, A> { + pub fn profile_filter_links_update(&self, request: &ProfileFilterLink, account_id: &str, web_property_id: &str, profile_id: &str, link_id: &str) -> ManagementProfileFilterLinkUpdateCall<'a, C, A> { ManagementProfileFilterLinkUpdateCall { hub: self.hub, _request: request.clone(), @@ -3651,7 +3647,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `webPropertyId` - Web property ID to retrieve the experiment for. /// * `profileId` - View (Profile) ID to retrieve the experiment for. /// * `experimentId` - Experiment ID to retrieve the experiment for. - pub fn experiments_get(&self, account_id: &str, web_property_id: &str, profile_id: &str, experiment_id: &str) -> ManagementExperimentGetCall<'a, C, NC, A> { + pub fn experiments_get(&self, account_id: &str, web_property_id: &str, profile_id: &str, experiment_id: &str) -> ManagementExperimentGetCall<'a, C, A> { ManagementExperimentGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -3674,7 +3670,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account ID for the custom dimension to update. /// * `webPropertyId` - Web property ID for the custom dimension to update. /// * `customDimensionId` - Custom dimension ID for the custom dimension to update. - pub fn custom_dimensions_update(&self, request: &CustomDimension, account_id: &str, web_property_id: &str, custom_dimension_id: &str) -> ManagementCustomDimensionUpdateCall<'a, C, NC, A> { + pub fn custom_dimensions_update(&self, request: &CustomDimension, account_id: &str, web_property_id: &str, custom_dimension_id: &str) -> ManagementCustomDimensionUpdateCall<'a, C, A> { ManagementCustomDimensionUpdateCall { hub: self.hub, _request: request.clone(), @@ -3698,7 +3694,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `webPropertyId` - Web property ID to retrieve unsampled reports for. /// * `profileId` - View (Profile) ID to retrieve unsampled report for. /// * `unsampledReportId` - ID of the unsampled report to retrieve. - pub fn unsampled_reports_get(&self, account_id: &str, web_property_id: &str, profile_id: &str, unsampled_report_id: &str) -> ManagementUnsampledReportGetCall<'a, C, NC, A> { + pub fn unsampled_reports_get(&self, account_id: &str, web_property_id: &str, profile_id: &str, unsampled_report_id: &str) -> ManagementUnsampledReportGetCall<'a, C, A> { ManagementUnsampledReportGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -3721,7 +3717,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account ID to create profile filter link for. /// * `webPropertyId` - Web property Id to create profile filter link for. /// * `profileId` - Profile ID to create filter link for. - pub fn profile_filter_links_insert(&self, request: &ProfileFilterLink, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementProfileFilterLinkInsertCall<'a, C, NC, A> { + pub fn profile_filter_links_insert(&self, request: &ProfileFilterLink, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementProfileFilterLinkInsertCall<'a, C, A> { ManagementProfileFilterLinkInsertCall { hub: self.hub, _request: request.clone(), @@ -3743,7 +3739,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - Account ID to which the filter belongs. /// * `filterId` - ID of the filter to be updated. - pub fn filters_update(&self, request: &Filter, account_id: &str, filter_id: &str) -> ManagementFilterUpdateCall<'a, C, NC, A> { + pub fn filters_update(&self, request: &Filter, account_id: &str, filter_id: &str) -> ManagementFilterUpdateCall<'a, C, A> { ManagementFilterUpdateCall { hub: self.hub, _request: request.clone(), @@ -3765,7 +3761,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `webPropertyId` - Web property Id to which the profile filter link belongs. /// * `profileId` - Profile ID to which the filter link belongs. /// * `linkId` - ID of the profile filter link to delete. - pub fn profile_filter_links_delete(&self, account_id: &str, web_property_id: &str, profile_id: &str, link_id: &str) -> ManagementProfileFilterLinkDeleteCall<'a, C, NC, A> { + pub fn profile_filter_links_delete(&self, account_id: &str, web_property_id: &str, profile_id: &str, link_id: &str) -> ManagementProfileFilterLinkDeleteCall<'a, C, A> { ManagementProfileFilterLinkDeleteCall { hub: self.hub, _account_id: account_id.to_string(), @@ -3781,7 +3777,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Lists segments to which the user has access. - pub fn segments_list(&self) -> ManagementSegmentListCall<'a, C, NC, A> { + pub fn segments_list(&self) -> ManagementSegmentListCall<'a, C, A> { ManagementSegmentListCall { hub: self.hub, _start_index: Default::default(), @@ -3801,7 +3797,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account ID to delete the view (profile) for. /// * `webPropertyId` - Web property ID to delete the view (profile) for. /// * `profileId` - ID of the view (profile) to be deleted. - pub fn profiles_delete(&self, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementProfileDeleteCall<'a, C, NC, A> { + pub fn profiles_delete(&self, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementProfileDeleteCall<'a, C, A> { ManagementProfileDeleteCall { hub: self.hub, _account_id: account_id.to_string(), @@ -3824,7 +3820,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `webPropertyId` - Web property ID to update the goal. /// * `profileId` - View (Profile) ID to update the goal. /// * `goalId` - Index of the goal to be updated. - pub fn goals_patch(&self, request: &Goal, account_id: &str, web_property_id: &str, profile_id: &str, goal_id: &str) -> ManagementGoalPatchCall<'a, C, NC, A> { + pub fn goals_patch(&self, request: &Goal, account_id: &str, web_property_id: &str, profile_id: &str, goal_id: &str) -> ManagementGoalPatchCall<'a, C, A> { ManagementGoalPatchCall { hub: self.hub, _request: request.clone(), @@ -3848,7 +3844,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account ID for the custom dimension to update. /// * `webPropertyId` - Web property ID for the custom dimension to update. /// * `customDimensionId` - Custom dimension ID for the custom dimension to update. - pub fn custom_dimensions_patch(&self, request: &CustomDimension, account_id: &str, web_property_id: &str, custom_dimension_id: &str) -> ManagementCustomDimensionPatchCall<'a, C, NC, A> { + pub fn custom_dimensions_patch(&self, request: &CustomDimension, account_id: &str, web_property_id: &str, custom_dimension_id: &str) -> ManagementCustomDimensionPatchCall<'a, C, A> { ManagementCustomDimensionPatchCall { hub: self.hub, _request: request.clone(), @@ -3873,7 +3869,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `webPropertyId` - Web property ID of the experiment to update. /// * `profileId` - View (Profile) ID of the experiment to update. /// * `experimentId` - Experiment ID of the experiment to update. - pub fn experiments_patch(&self, request: &Experiment, account_id: &str, web_property_id: &str, profile_id: &str, experiment_id: &str) -> ManagementExperimentPatchCall<'a, C, NC, A> { + pub fn experiments_patch(&self, request: &Experiment, account_id: &str, web_property_id: &str, profile_id: &str, experiment_id: &str) -> ManagementExperimentPatchCall<'a, C, A> { ManagementExperimentPatchCall { hub: self.hub, _request: request.clone(), @@ -3896,7 +3892,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account ID to retrieve experiments for. /// * `webPropertyId` - Web property ID to retrieve experiments for. /// * `profileId` - View (Profile) ID to retrieve experiments for. - pub fn experiments_list(&self, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementExperimentListCall<'a, C, NC, A> { + pub fn experiments_list(&self, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementExperimentListCall<'a, C, A> { ManagementExperimentListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -3918,7 +3914,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// /// * `accountId` - Account ID for the view (profiles) to retrieve. Can either be a specific account ID or '~all', which refers to all the accounts to which the user has access. /// * `webPropertyId` - Web property ID for the views (profiles) to retrieve. Can either be a specific web property ID or '~all', which refers to all the web properties to which the user has access. - pub fn profiles_list(&self, account_id: &str, web_property_id: &str) -> ManagementProfileListCall<'a, C, NC, A> { + pub fn profiles_list(&self, account_id: &str, web_property_id: &str) -> ManagementProfileListCall<'a, C, A> { ManagementProfileListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -3940,7 +3936,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account ID to retrieve goals for. Can either be a specific account ID or '~all', which refers to all the accounts that user has access to. /// * `webPropertyId` - Web property ID to retrieve goals for. Can either be a specific web property ID or '~all', which refers to all the web properties that user has access to. /// * `profileId` - View (Profile) ID to retrieve goals for. Can either be a specific view (profile) ID or '~all', which refers to all the views (profiles) that user has access to. - pub fn goals_list(&self, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementGoalListCall<'a, C, NC, A> { + pub fn goals_list(&self, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementGoalListCall<'a, C, A> { ManagementGoalListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -3964,7 +3960,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account ID to create the goal for. /// * `webPropertyId` - Web property ID to create the goal for. /// * `profileId` - View (Profile) ID to create the goal for. - pub fn goals_insert(&self, request: &Goal, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementGoalInsertCall<'a, C, NC, A> { + pub fn goals_insert(&self, request: &Goal, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementGoalInsertCall<'a, C, A> { ManagementGoalInsertCall { hub: self.hub, _request: request.clone(), @@ -3987,7 +3983,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account ID for the custom metric to update. /// * `webPropertyId` - Web property ID for the custom metric to update. /// * `customMetricId` - Custom metric ID for the custom metric to update. - pub fn custom_metrics_patch(&self, request: &CustomMetric, account_id: &str, web_property_id: &str, custom_metric_id: &str) -> ManagementCustomMetricPatchCall<'a, C, NC, A> { + pub fn custom_metrics_patch(&self, request: &CustomMetric, account_id: &str, web_property_id: &str, custom_metric_id: &str) -> ManagementCustomMetricPatchCall<'a, C, A> { ManagementCustomMetricPatchCall { hub: self.hub, _request: request.clone(), @@ -4010,7 +4006,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account Id associated with the upload. /// * `webPropertyId` - Web property UA-string associated with the upload. /// * `customDataSourceId` - Custom data source Id to which the data being uploaded belongs. - pub fn uploads_upload_data(&self, account_id: &str, web_property_id: &str, custom_data_source_id: &str) -> ManagementUploadUploadDataCall<'a, C, NC, A> { + pub fn uploads_upload_data(&self, account_id: &str, web_property_id: &str, custom_data_source_id: &str) -> ManagementUploadUploadDataCall<'a, C, A> { ManagementUploadUploadDataCall { hub: self.hub, _account_id: account_id.to_string(), @@ -4030,7 +4026,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `accountId` - Account ID to create the user link for. - pub fn account_user_links_insert(&self, request: &EntityUserLink, account_id: &str) -> ManagementAccountUserLinkInsertCall<'a, C, NC, A> { + pub fn account_user_links_insert(&self, request: &EntityUserLink, account_id: &str) -> ManagementAccountUserLinkInsertCall<'a, C, A> { ManagementAccountUserLinkInsertCall { hub: self.hub, _request: request.clone(), @@ -4050,7 +4046,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - Account ID to create the user link for. /// * `webPropertyId` - Web Property ID to create the user link for. - pub fn webproperty_user_links_insert(&self, request: &EntityUserLink, account_id: &str, web_property_id: &str) -> ManagementWebpropertyUserLinkInsertCall<'a, C, NC, A> { + pub fn webproperty_user_links_insert(&self, request: &EntityUserLink, account_id: &str, web_property_id: &str) -> ManagementWebpropertyUserLinkInsertCall<'a, C, A> { ManagementWebpropertyUserLinkInsertCall { hub: self.hub, _request: request.clone(), @@ -4072,7 +4068,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `webPropertyId` - Web property ID to which the experiment belongs /// * `profileId` - View (Profile) ID to which the experiment belongs /// * `experimentId` - ID of the experiment to delete - pub fn experiments_delete(&self, account_id: &str, web_property_id: &str, profile_id: &str, experiment_id: &str) -> ManagementExperimentDeleteCall<'a, C, NC, A> { + pub fn experiments_delete(&self, account_id: &str, web_property_id: &str, profile_id: &str, experiment_id: &str) -> ManagementExperimentDeleteCall<'a, C, A> { ManagementExperimentDeleteCall { hub: self.hub, _account_id: account_id.to_string(), @@ -4095,7 +4091,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account ID to which the view (profile) belongs /// * `webPropertyId` - Web property ID to which the view (profile) belongs /// * `profileId` - ID of the view (profile) to be updated. - pub fn profiles_patch(&self, request: &Profile, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementProfilePatchCall<'a, C, NC, A> { + pub fn profiles_patch(&self, request: &Profile, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementProfilePatchCall<'a, C, A> { ManagementProfilePatchCall { hub: self.hub, _request: request.clone(), @@ -4116,7 +4112,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// /// * `accountId` - Account ID to retrieve filters for. /// * `filterId` - Filter ID to retrieve filters for. - pub fn filters_get(&self, account_id: &str, filter_id: &str) -> ManagementFilterGetCall<'a, C, NC, A> { + pub fn filters_get(&self, account_id: &str, filter_id: &str) -> ManagementFilterGetCall<'a, C, A> { ManagementFilterGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -4135,7 +4131,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// /// * `accountId` - ID of the account which the given web property belongs to. /// * `webPropertyId` - Web property ID to retrieve the AdWords links for. - pub fn web_property_ad_words_links_list(&self, account_id: &str, web_property_id: &str) -> ManagementWebPropertyAdWordsLinkListCall<'a, C, NC, A> { + pub fn web_property_ad_words_links_list(&self, account_id: &str, web_property_id: &str) -> ManagementWebPropertyAdWordsLinkListCall<'a, C, A> { ManagementWebPropertyAdWordsLinkListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -4151,7 +4147,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Lists account summaries (lightweight tree comprised of accounts/properties/profiles) to which the user has access. - pub fn account_summaries_list(&self) -> ManagementAccountSummaryListCall<'a, C, NC, A> { + pub fn account_summaries_list(&self) -> ManagementAccountSummaryListCall<'a, C, A> { ManagementAccountSummaryListCall { hub: self.hub, _start_index: Default::default(), @@ -4170,7 +4166,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// /// * `accountId` - Account ID for the custom dimensions to retrieve. /// * `webPropertyId` - Web property ID for the custom dimensions to retrieve. - pub fn custom_dimensions_list(&self, account_id: &str, web_property_id: &str) -> ManagementCustomDimensionListCall<'a, C, NC, A> { + pub fn custom_dimensions_list(&self, account_id: &str, web_property_id: &str) -> ManagementCustomDimensionListCall<'a, C, A> { ManagementCustomDimensionListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -4192,7 +4188,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account Id for the uploads to retrieve. /// * `webPropertyId` - Web property Id for the uploads to retrieve. /// * `customDataSourceId` - Custom data source Id for uploads to retrieve. - pub fn uploads_list(&self, account_id: &str, web_property_id: &str, custom_data_source_id: &str) -> ManagementUploadListCall<'a, C, NC, A> { + pub fn uploads_list(&self, account_id: &str, web_property_id: &str, custom_data_source_id: &str) -> ManagementUploadListCall<'a, C, A> { ManagementUploadListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -4215,7 +4211,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account ID which the given view (profile) belongs to. /// * `webPropertyId` - Web Property ID which the given view (profile) belongs to. Can either be a specific web property ID or '~all', which refers to all the web properties that user has access to. /// * `profileId` - View (Profile) ID to retrieve the profile-user links for. Can either be a specific profile ID or '~all', which refers to all the profiles that user has access to. - pub fn profile_user_links_list(&self, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementProfileUserLinkListCall<'a, C, NC, A> { + pub fn profile_user_links_list(&self, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementProfileUserLinkListCall<'a, C, A> { ManagementProfileUserLinkListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -4236,7 +4232,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// # Arguments /// /// * `accountId` - Account ID to retrieve the user links for. - pub fn account_user_links_list(&self, account_id: &str) -> ManagementAccountUserLinkListCall<'a, C, NC, A> { + pub fn account_user_links_list(&self, account_id: &str) -> ManagementAccountUserLinkListCall<'a, C, A> { ManagementAccountUserLinkListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -4258,7 +4254,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account ID for the custom metric to update. /// * `webPropertyId` - Web property ID for the custom metric to update. /// * `customMetricId` - Custom metric ID for the custom metric to update. - pub fn custom_metrics_update(&self, request: &CustomMetric, account_id: &str, web_property_id: &str, custom_metric_id: &str) -> ManagementCustomMetricUpdateCall<'a, C, NC, A> { + pub fn custom_metrics_update(&self, request: &CustomMetric, account_id: &str, web_property_id: &str, custom_metric_id: &str) -> ManagementCustomMetricUpdateCall<'a, C, A> { ManagementCustomMetricUpdateCall { hub: self.hub, _request: request.clone(), @@ -4282,7 +4278,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account Id for the uploads to be deleted. /// * `webPropertyId` - Web property Id for the uploads to be deleted. /// * `customDataSourceId` - Custom data source Id for the uploads to be deleted. - pub fn uploads_delete_upload_data(&self, request: &AnalyticsDataimportDeleteUploadDataRequest, account_id: &str, web_property_id: &str, custom_data_source_id: &str) -> ManagementUploadDeleteUploadDataCall<'a, C, NC, A> { + pub fn uploads_delete_upload_data(&self, request: &AnalyticsDataimportDeleteUploadDataRequest, account_id: &str, web_property_id: &str, custom_data_source_id: &str) -> ManagementUploadDeleteUploadDataCall<'a, C, A> { ManagementUploadDeleteUploadDataCall { hub: self.hub, _request: request.clone(), @@ -4306,7 +4302,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `webPropertyId` - Web property ID of the experiment to update. /// * `profileId` - View (Profile) ID of the experiment to update. /// * `experimentId` - Experiment ID of the experiment to update. - pub fn experiments_update(&self, request: &Experiment, account_id: &str, web_property_id: &str, profile_id: &str, experiment_id: &str) -> ManagementExperimentUpdateCall<'a, C, NC, A> { + pub fn experiments_update(&self, request: &Experiment, account_id: &str, web_property_id: &str, profile_id: &str, experiment_id: &str) -> ManagementExperimentUpdateCall<'a, C, A> { ManagementExperimentUpdateCall { hub: self.hub, _request: request.clone(), @@ -4331,7 +4327,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `webPropertyId` - Web property ID to update the goal. /// * `profileId` - View (Profile) ID to update the goal. /// * `goalId` - Index of the goal to be updated. - pub fn goals_update(&self, request: &Goal, account_id: &str, web_property_id: &str, profile_id: &str, goal_id: &str) -> ManagementGoalUpdateCall<'a, C, NC, A> { + pub fn goals_update(&self, request: &Goal, account_id: &str, web_property_id: &str, profile_id: &str, goal_id: &str) -> ManagementGoalUpdateCall<'a, C, A> { ManagementGoalUpdateCall { hub: self.hub, _request: request.clone(), @@ -4353,7 +4349,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// /// * `accountId` - Account Id for the custom data sources to retrieve. /// * `webPropertyId` - Web property Id for the custom data sources to retrieve. - pub fn custom_data_sources_list(&self, account_id: &str, web_property_id: &str) -> ManagementCustomDataSourceListCall<'a, C, NC, A> { + pub fn custom_data_sources_list(&self, account_id: &str, web_property_id: &str) -> ManagementCustomDataSourceListCall<'a, C, A> { ManagementCustomDataSourceListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -4374,7 +4370,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// /// * `accountId` - Account ID for the custom metrics to retrieve. /// * `webPropertyId` - Web property ID for the custom metrics to retrieve. - pub fn custom_metrics_list(&self, account_id: &str, web_property_id: &str) -> ManagementCustomMetricListCall<'a, C, NC, A> { + pub fn custom_metrics_list(&self, account_id: &str, web_property_id: &str) -> ManagementCustomMetricListCall<'a, C, A> { ManagementCustomMetricListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -4396,7 +4392,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account ID to retrieve unsampled reports for. Must be a specific account ID, ~all is not supported. /// * `webPropertyId` - Web property ID to retrieve unsampled reports for. Must be a specific web property ID, ~all is not supported. /// * `profileId` - View (Profile) ID to retrieve unsampled reports for. Must be a specific view (profile) ID, ~all is not supported. - pub fn unsampled_reports_list(&self, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementUnsampledReportListCall<'a, C, NC, A> { + pub fn unsampled_reports_list(&self, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementUnsampledReportListCall<'a, C, A> { ManagementUnsampledReportListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -4418,7 +4414,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// /// * `accountId` - Account ID to retrieve the web property for. /// * `webPropertyId` - ID to retrieve the web property for. - pub fn webproperties_get(&self, account_id: &str, web_property_id: &str) -> ManagementWebpropertyGetCall<'a, C, NC, A> { + pub fn webproperties_get(&self, account_id: &str, web_property_id: &str) -> ManagementWebpropertyGetCall<'a, C, A> { ManagementWebpropertyGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -4439,7 +4435,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account ID to create the experiment for. /// * `webPropertyId` - Web property ID to create the experiment for. /// * `profileId` - View (Profile) ID to create the experiment for. - pub fn experiments_insert(&self, request: &Experiment, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementExperimentInsertCall<'a, C, NC, A> { + pub fn experiments_insert(&self, request: &Experiment, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementExperimentInsertCall<'a, C, A> { ManagementExperimentInsertCall { hub: self.hub, _request: request.clone(), @@ -4461,7 +4457,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account ID for the custom dimension to retrieve. /// * `webPropertyId` - Web property ID for the custom dimension to retrieve. /// * `customDimensionId` - The ID of the custom dimension to retrieve. - pub fn custom_dimensions_get(&self, account_id: &str, web_property_id: &str, custom_dimension_id: &str) -> ManagementCustomDimensionGetCall<'a, C, NC, A> { + pub fn custom_dimensions_get(&self, account_id: &str, web_property_id: &str, custom_dimension_id: &str) -> ManagementCustomDimensionGetCall<'a, C, A> { ManagementCustomDimensionGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -4482,7 +4478,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account ID to retrieve profile filter links for. /// * `webPropertyId` - Web property Id for profile filter links for. Can either be a specific web property ID or '~all', which refers to all the web properties that user has access to. /// * `profileId` - Profile ID to retrieve filter links for. Can either be a specific profile ID or '~all', which refers to all the profiles that user has access to. - pub fn profile_filter_links_list(&self, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementProfileFilterLinkListCall<'a, C, NC, A> { + pub fn profile_filter_links_list(&self, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementProfileFilterLinkListCall<'a, C, A> { ManagementProfileFilterLinkListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -4505,7 +4501,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - Account ID to which the web property belongs /// * `webPropertyId` - Web property ID - pub fn webproperties_patch(&self, request: &Webproperty, account_id: &str, web_property_id: &str) -> ManagementWebpropertyPatchCall<'a, C, NC, A> { + pub fn webproperties_patch(&self, request: &Webproperty, account_id: &str, web_property_id: &str) -> ManagementWebpropertyPatchCall<'a, C, A> { ManagementWebpropertyPatchCall { hub: self.hub, _request: request.clone(), @@ -4526,7 +4522,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - Account ID for the custom dimension to create. /// * `webPropertyId` - Web property ID for the custom dimension to create. - pub fn custom_dimensions_insert(&self, request: &CustomDimension, account_id: &str, web_property_id: &str) -> ManagementCustomDimensionInsertCall<'a, C, NC, A> { + pub fn custom_dimensions_insert(&self, request: &CustomDimension, account_id: &str, web_property_id: &str) -> ManagementCustomDimensionInsertCall<'a, C, A> { ManagementCustomDimensionInsertCall { hub: self.hub, _request: request.clone(), @@ -4547,7 +4543,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - Account ID for the custom metric to create. /// * `webPropertyId` - Web property ID for the custom dimension to create. - pub fn custom_metrics_insert(&self, request: &CustomMetric, account_id: &str, web_property_id: &str) -> ManagementCustomMetricInsertCall<'a, C, NC, A> { + pub fn custom_metrics_insert(&self, request: &CustomMetric, account_id: &str, web_property_id: &str) -> ManagementCustomMetricInsertCall<'a, C, A> { ManagementCustomMetricInsertCall { hub: self.hub, _request: request.clone(), @@ -4569,7 +4565,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account ID to create the user link for. /// * `webPropertyId` - Web Property ID to create the user link for. /// * `profileId` - View (Profile) ID to create the user link for. - pub fn profile_user_links_insert(&self, request: &EntityUserLink, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementProfileUserLinkInsertCall<'a, C, NC, A> { + pub fn profile_user_links_insert(&self, request: &EntityUserLink, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementProfileUserLinkInsertCall<'a, C, A> { ManagementProfileUserLinkInsertCall { hub: self.hub, _request: request.clone(), @@ -4589,7 +4585,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// # Arguments /// /// * `accountId` - Account ID to retrieve web properties for. Can either be a specific account ID or '~all', which refers to all the accounts that user has access to. - pub fn webproperties_list(&self, account_id: &str) -> ManagementWebpropertyListCall<'a, C, NC, A> { + pub fn webproperties_list(&self, account_id: &str) -> ManagementWebpropertyListCall<'a, C, A> { ManagementWebpropertyListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -4610,7 +4606,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - ID of the Google Analytics account to create the link for. /// * `webPropertyId` - Web property ID to create the link for. - pub fn web_property_ad_words_links_insert(&self, request: &EntityAdWordsLink, account_id: &str, web_property_id: &str) -> ManagementWebPropertyAdWordsLinkInsertCall<'a, C, NC, A> { + pub fn web_property_ad_words_links_insert(&self, request: &EntityAdWordsLink, account_id: &str, web_property_id: &str) -> ManagementWebPropertyAdWordsLinkInsertCall<'a, C, A> { ManagementWebPropertyAdWordsLinkInsertCall { hub: self.hub, _request: request.clone(), @@ -4632,7 +4628,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - ID of the account which the given web property belongs to. /// * `webPropertyId` - Web property ID to retrieve the AdWords link for. /// * `webPropertyAdWordsLinkId` - Web property-AdWords link ID. - pub fn web_property_ad_words_links_patch(&self, request: &EntityAdWordsLink, account_id: &str, web_property_id: &str, web_property_ad_words_link_id: &str) -> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, NC, A> { + pub fn web_property_ad_words_links_patch(&self, request: &EntityAdWordsLink, account_id: &str, web_property_id: &str, web_property_ad_words_link_id: &str) -> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, A> { ManagementWebPropertyAdWordsLinkPatchCall { hub: self.hub, _request: request.clone(), @@ -4655,7 +4651,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `webPropertyId` - Web property ID to retrieve the goal for. /// * `profileId` - View (Profile) ID to retrieve the goal for. /// * `goalId` - Goal ID to retrieve the goal for. - pub fn goals_get(&self, account_id: &str, web_property_id: &str, profile_id: &str, goal_id: &str) -> ManagementGoalGetCall<'a, C, NC, A> { + pub fn goals_get(&self, account_id: &str, web_property_id: &str, profile_id: &str, goal_id: &str) -> ManagementGoalGetCall<'a, C, A> { ManagementGoalGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -4677,7 +4673,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - ID of the account which the given web property belongs to. /// * `webPropertyId` - Web property ID to delete the AdWords link for. /// * `webPropertyAdWordsLinkId` - Web property AdWords link ID. - pub fn web_property_ad_words_links_delete(&self, account_id: &str, web_property_id: &str, web_property_ad_words_link_id: &str) -> ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, NC, A> { + pub fn web_property_ad_words_links_delete(&self, account_id: &str, web_property_id: &str, web_property_ad_words_link_id: &str) -> ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, A> { ManagementWebPropertyAdWordsLinkDeleteCall { hub: self.hub, _account_id: account_id.to_string(), @@ -4699,7 +4695,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - ID of the account which the given web property belongs to. /// * `webPropertyId` - Web property ID to retrieve the AdWords link for. /// * `webPropertyAdWordsLinkId` - Web property-AdWords link ID. - pub fn web_property_ad_words_links_update(&self, request: &EntityAdWordsLink, account_id: &str, web_property_id: &str, web_property_ad_words_link_id: &str) -> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, NC, A> { + pub fn web_property_ad_words_links_update(&self, request: &EntityAdWordsLink, account_id: &str, web_property_id: &str, web_property_ad_words_link_id: &str) -> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, A> { ManagementWebPropertyAdWordsLinkUpdateCall { hub: self.hub, _request: request.clone(), @@ -4721,7 +4717,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - Account ID to which the filter belongs. /// * `filterId` - ID of the filter to be updated. - pub fn filters_patch(&self, request: &Filter, account_id: &str, filter_id: &str) -> ManagementFilterPatchCall<'a, C, NC, A> { + pub fn filters_patch(&self, request: &Filter, account_id: &str, filter_id: &str) -> ManagementFilterPatchCall<'a, C, A> { ManagementFilterPatchCall { hub: self.hub, _request: request.clone(), @@ -4740,7 +4736,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// # Arguments /// /// * `accountId` - Account ID to retrieve filters for. - pub fn filters_list(&self, account_id: &str) -> ManagementFilterListCall<'a, C, NC, A> { + pub fn filters_list(&self, account_id: &str) -> ManagementFilterListCall<'a, C, A> { ManagementFilterListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -4760,7 +4756,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// /// * `accountId` - Account ID to delete the filter for. /// * `filterId` - ID of the filter to be deleted. - pub fn filters_delete(&self, account_id: &str, filter_id: &str) -> ManagementFilterDeleteCall<'a, C, NC, A> { + pub fn filters_delete(&self, account_id: &str, filter_id: &str) -> ManagementFilterDeleteCall<'a, C, A> { ManagementFilterDeleteCall { hub: self.hub, _account_id: account_id.to_string(), @@ -4780,7 +4776,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - Account ID to create the view (profile) for. /// * `webPropertyId` - Web property ID to create the view (profile) for. - pub fn profiles_insert(&self, request: &Profile, account_id: &str, web_property_id: &str) -> ManagementProfileInsertCall<'a, C, NC, A> { + pub fn profiles_insert(&self, request: &Profile, account_id: &str, web_property_id: &str) -> ManagementProfileInsertCall<'a, C, A> { ManagementProfileInsertCall { hub: self.hub, _request: request.clone(), @@ -4800,7 +4796,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// /// * `accountId` - Account ID to delete the user link for. /// * `linkId` - Link ID to delete the user link for. - pub fn account_user_links_delete(&self, account_id: &str, link_id: &str) -> ManagementAccountUserLinkDeleteCall<'a, C, NC, A> { + pub fn account_user_links_delete(&self, account_id: &str, link_id: &str) -> ManagementAccountUserLinkDeleteCall<'a, C, A> { ManagementAccountUserLinkDeleteCall { hub: self.hub, _account_id: account_id.to_string(), @@ -4821,7 +4817,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `accountId` - Account ID to which the view (profile) belongs /// * `webPropertyId` - Web property ID to which the view (profile) belongs /// * `profileId` - ID of the view (profile) to be updated. - pub fn profiles_update(&self, request: &Profile, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementProfileUpdateCall<'a, C, NC, A> { + pub fn profiles_update(&self, request: &Profile, account_id: &str, web_property_id: &str, profile_id: &str) -> ManagementProfileUpdateCall<'a, C, A> { ManagementProfileUpdateCall { hub: self.hub, _request: request.clone(), @@ -4844,7 +4840,7 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// * `webPropertyId` - Web property Id to retrieve profile filter link for. /// * `profileId` - Profile ID to retrieve filter link for. /// * `linkId` - ID of the profile filter link. - pub fn profile_filter_links_get(&self, account_id: &str, web_property_id: &str, profile_id: &str, link_id: &str) -> ManagementProfileFilterLinkGetCall<'a, C, NC, A> { + pub fn profile_filter_links_get(&self, account_id: &str, web_property_id: &str, profile_id: &str, link_id: &str) -> ManagementProfileFilterLinkGetCall<'a, C, A> { ManagementProfileFilterLinkGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -4888,15 +4884,15 @@ impl<'a, C, NC, A> ManagementMethods<'a, C, NC, A> { /// let rb = hub.data(); /// # } /// ``` -pub struct DataMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DataMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, } -impl<'a, C, NC, A> MethodsBuilder for DataMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for DataMethods<'a, C, A> {} -impl<'a, C, NC, A> DataMethods<'a, C, NC, A> { +impl<'a, C, A> DataMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -4908,7 +4904,7 @@ impl<'a, C, NC, A> DataMethods<'a, C, NC, A> { /// * `start-date` - Start date for fetching Analytics data. Requests can specify a start date formatted as YYYY-MM-DD, or as a relative date (e.g., today, yesterday, or 7daysAgo). The default value is 7daysAgo. /// * `end-date` - End date for fetching Analytics data. Requests can specify a start date formatted as YYYY-MM-DD, or as a relative date (e.g., today, yesterday, or 7daysAgo). The default value is 7daysAgo. /// * `metrics` - A comma-separated list of Multi-Channel Funnels metrics. E.g., 'mcf:totalConversions,mcf:totalConversionValue'. At least one metric must be specified. - pub fn mcf_get(&self, ids: &str, start_date: &str, end_date: &str, metrics: &str) -> DataMcfGetCall<'a, C, NC, A> { + pub fn mcf_get(&self, ids: &str, start_date: &str, end_date: &str, metrics: &str) -> DataMcfGetCall<'a, C, A> { DataMcfGetCall { hub: self.hub, _ids: ids.to_string(), @@ -4937,7 +4933,7 @@ impl<'a, C, NC, A> DataMethods<'a, C, NC, A> { /// * `start-date` - Start date for fetching Analytics data. Requests can specify a start date formatted as YYYY-MM-DD, or as a relative date (e.g., today, yesterday, or 7daysAgo). The default value is 7daysAgo. /// * `end-date` - End date for fetching Analytics data. Request can should specify an end date formatted as YYYY-MM-DD, or as a relative date (e.g., today, yesterday, or 7daysAgo). The default value is yesterday. /// * `metrics` - A comma-separated list of Analytics metrics. E.g., 'ga:sessions,ga:pageviews'. At least one metric must be specified. - pub fn ga_get(&self, ids: &str, start_date: &str, end_date: &str, metrics: &str) -> DataGaGetCall<'a, C, NC, A> { + pub fn ga_get(&self, ids: &str, start_date: &str, end_date: &str, metrics: &str) -> DataGaGetCall<'a, C, A> { DataGaGetCall { hub: self.hub, _ids: ids.to_string(), @@ -4966,7 +4962,7 @@ impl<'a, C, NC, A> DataMethods<'a, C, NC, A> { /// /// * `ids` - Unique table ID for retrieving real time data. Table ID is of the form ga:XXXX, where XXXX is the Analytics view (profile) ID. /// * `metrics` - A comma-separated list of real time metrics. E.g., 'rt:activeUsers'. At least one metric must be specified. - pub fn realtime_get(&self, ids: &str, metrics: &str) -> DataRealtimeGetCall<'a, C, NC, A> { + pub fn realtime_get(&self, ids: &str, metrics: &str) -> DataRealtimeGetCall<'a, C, A> { DataRealtimeGetCall { hub: self.hub, _ids: ids.to_string(), @@ -5012,15 +5008,15 @@ impl<'a, C, NC, A> DataMethods<'a, C, NC, A> { /// let rb = hub.provisioning(); /// # } /// ``` -pub struct ProvisioningMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProvisioningMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, } -impl<'a, C, NC, A> MethodsBuilder for ProvisioningMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ProvisioningMethods<'a, C, A> {} -impl<'a, C, NC, A> ProvisioningMethods<'a, C, NC, A> { +impl<'a, C, A> ProvisioningMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -5029,7 +5025,7 @@ impl<'a, C, NC, A> ProvisioningMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn create_account_ticket(&self, request: &AccountTicket) -> ProvisioningCreateAccountTicketCall<'a, C, NC, A> { + pub fn create_account_ticket(&self, request: &AccountTicket) -> ProvisioningCreateAccountTicketCall<'a, C, A> { ProvisioningCreateAccountTicketCall { hub: self.hub, _request: request.clone(), @@ -5070,15 +5066,15 @@ impl<'a, C, NC, A> ProvisioningMethods<'a, C, NC, A> { /// let rb = hub.metadata(); /// # } /// ``` -pub struct MetadataMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MetadataMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, } -impl<'a, C, NC, A> MethodsBuilder for MetadataMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for MetadataMethods<'a, C, A> {} -impl<'a, C, NC, A> MetadataMethods<'a, C, NC, A> { +impl<'a, C, A> MetadataMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -5087,7 +5083,7 @@ impl<'a, C, NC, A> MetadataMethods<'a, C, NC, A> { /// # Arguments /// /// * `reportType` - Report type. Allowed Values: 'ga'. Where 'ga' corresponds to the Core Reporting API - pub fn columns_list(&self, report_type: &str) -> MetadataColumnListCall<'a, C, NC, A> { + pub fn columns_list(&self, report_type: &str) -> MetadataColumnListCall<'a, C, A> { MetadataColumnListCall { hub: self.hub, _report_type: report_type.to_string(), @@ -5142,10 +5138,10 @@ impl<'a, C, NC, A> MetadataMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct ManagementWebpropertyInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementWebpropertyInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: Webproperty, _account_id: String, _delegate: Option<&'a mut Delegate>, @@ -5153,9 +5149,9 @@ pub struct ManagementWebpropertyInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementWebpropertyInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementWebpropertyInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementWebpropertyInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementWebpropertyInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5294,7 +5290,7 @@ impl<'a, C, NC, A> ManagementWebpropertyInsertCall<'a, C, NC, A> where NC: hyper /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Webproperty) -> ManagementWebpropertyInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Webproperty) -> ManagementWebpropertyInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5304,7 +5300,7 @@ impl<'a, C, NC, A> ManagementWebpropertyInsertCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// Account ID to create the web property for. - pub fn account_id(mut self, new_value: &str) -> ManagementWebpropertyInsertCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementWebpropertyInsertCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -5315,7 +5311,7 @@ impl<'a, C, NC, A> ManagementWebpropertyInsertCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebpropertyInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebpropertyInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5336,7 +5332,7 @@ impl<'a, C, NC, A> ManagementWebpropertyInsertCall<'a, C, NC, A> where NC: hyper /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementWebpropertyInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementWebpropertyInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5353,7 +5349,7 @@ impl<'a, C, NC, A> ManagementWebpropertyInsertCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementWebpropertyInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementWebpropertyInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5391,10 +5387,10 @@ impl<'a, C, NC, A> ManagementWebpropertyInsertCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct ManagementProfileGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementProfileGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _profile_id: String, @@ -5403,9 +5399,9 @@ pub struct ManagementProfileGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementProfileGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementProfileGetCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementProfileGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementProfileGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5539,7 +5535,7 @@ impl<'a, C, NC, A> ManagementProfileGetCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Account ID to retrieve the goal for. - pub fn account_id(mut self, new_value: &str) -> ManagementProfileGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementProfileGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -5549,7 +5545,7 @@ impl<'a, C, NC, A> ManagementProfileGetCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Web property ID to retrieve the goal for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileGetCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileGetCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -5559,7 +5555,7 @@ impl<'a, C, NC, A> ManagementProfileGetCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// View (Profile) ID to retrieve the goal for. - pub fn profile_id(mut self, new_value: &str) -> ManagementProfileGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementProfileGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -5570,7 +5566,7 @@ impl<'a, C, NC, A> ManagementProfileGetCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5591,7 +5587,7 @@ impl<'a, C, NC, A> ManagementProfileGetCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementProfileGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementProfileGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5608,7 +5604,7 @@ impl<'a, C, NC, A> ManagementProfileGetCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementProfileGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementProfileGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5648,10 +5644,10 @@ impl<'a, C, NC, A> ManagementProfileGetCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct ManagementAccountListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementAccountListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _start_index: Option, _max_results: Option, _delegate: Option<&'a mut Delegate>, @@ -5659,9 +5655,9 @@ pub struct ManagementAccountListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementAccountListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementAccountListCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementAccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementAccountListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5772,7 +5768,7 @@ impl<'a, C, NC, A> ManagementAccountListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// An index of the first account to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter. - pub fn start_index(mut self, new_value: i32) -> ManagementAccountListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> ManagementAccountListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -5780,7 +5776,7 @@ impl<'a, C, NC, A> ManagementAccountListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// The maximum number of accounts to include in this response. - pub fn max_results(mut self, new_value: i32) -> ManagementAccountListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ManagementAccountListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -5791,7 +5787,7 @@ impl<'a, C, NC, A> ManagementAccountListCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementAccountListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementAccountListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5812,7 +5808,7 @@ impl<'a, C, NC, A> ManagementAccountListCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementAccountListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementAccountListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5829,7 +5825,7 @@ impl<'a, C, NC, A> ManagementAccountListCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementAccountListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementAccountListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5873,10 +5869,10 @@ impl<'a, C, NC, A> ManagementAccountListCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct ManagementProfileFilterLinkPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementProfileFilterLinkPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: ProfileFilterLink, _account_id: String, _web_property_id: String, @@ -5887,9 +5883,9 @@ pub struct ManagementProfileFilterLinkPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementProfileFilterLinkPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementProfileFilterLinkPatchCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementProfileFilterLinkPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementProfileFilterLinkPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6031,7 +6027,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkPatchCall<'a, C, NC, A> where NC: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ProfileFilterLink) -> ManagementProfileFilterLinkPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ProfileFilterLink) -> ManagementProfileFilterLinkPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6041,7 +6037,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkPatchCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Account ID to which profile filter link belongs. - pub fn account_id(mut self, new_value: &str) -> ManagementProfileFilterLinkPatchCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementProfileFilterLinkPatchCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -6051,7 +6047,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkPatchCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Web property Id to which profile filter link belongs - pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileFilterLinkPatchCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileFilterLinkPatchCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -6061,7 +6057,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkPatchCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Profile ID to which filter link belongs - pub fn profile_id(mut self, new_value: &str) -> ManagementProfileFilterLinkPatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementProfileFilterLinkPatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -6071,7 +6067,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkPatchCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// ID of the profile filter link to be updated. - pub fn link_id(mut self, new_value: &str) -> ManagementProfileFilterLinkPatchCall<'a, C, NC, A> { + pub fn link_id(mut self, new_value: &str) -> ManagementProfileFilterLinkPatchCall<'a, C, A> { self._link_id = new_value.to_string(); self } @@ -6082,7 +6078,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkPatchCall<'a, C, NC, A> where NC: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileFilterLinkPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileFilterLinkPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6103,7 +6099,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkPatchCall<'a, C, NC, A> where NC: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementProfileFilterLinkPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementProfileFilterLinkPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6120,7 +6116,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkPatchCall<'a, C, NC, A> where NC: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementProfileFilterLinkPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementProfileFilterLinkPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6158,10 +6154,10 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkPatchCall<'a, C, NC, A> where NC: /// .doit(); /// # } /// ``` -pub struct ManagementWebpropertyUserLinkDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementWebpropertyUserLinkDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _link_id: String, @@ -6170,9 +6166,9 @@ pub struct ManagementWebpropertyUserLinkDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementWebpropertyUserLinkDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementWebpropertyUserLinkDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementWebpropertyUserLinkDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementWebpropertyUserLinkDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6295,7 +6291,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkDeleteCall<'a, C, NC, A> where N /// we provide this method for API completeness. /// /// Account ID to delete the user link for. - pub fn account_id(mut self, new_value: &str) -> ManagementWebpropertyUserLinkDeleteCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementWebpropertyUserLinkDeleteCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -6305,7 +6301,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkDeleteCall<'a, C, NC, A> where N /// we provide this method for API completeness. /// /// Web Property ID to delete the user link for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementWebpropertyUserLinkDeleteCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementWebpropertyUserLinkDeleteCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -6315,7 +6311,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkDeleteCall<'a, C, NC, A> where N /// we provide this method for API completeness. /// /// Link ID to delete the user link for. - pub fn link_id(mut self, new_value: &str) -> ManagementWebpropertyUserLinkDeleteCall<'a, C, NC, A> { + pub fn link_id(mut self, new_value: &str) -> ManagementWebpropertyUserLinkDeleteCall<'a, C, A> { self._link_id = new_value.to_string(); self } @@ -6326,7 +6322,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkDeleteCall<'a, C, NC, A> where N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebpropertyUserLinkDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebpropertyUserLinkDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6347,7 +6343,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkDeleteCall<'a, C, NC, A> where N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementWebpropertyUserLinkDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementWebpropertyUserLinkDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6364,7 +6360,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkDeleteCall<'a, C, NC, A> where N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementWebpropertyUserLinkDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementWebpropertyUserLinkDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6402,10 +6398,10 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkDeleteCall<'a, C, NC, A> where N /// .doit(); /// # } /// ``` -pub struct ManagementProfileUserLinkDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementProfileUserLinkDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _profile_id: String, @@ -6415,9 +6411,9 @@ pub struct ManagementProfileUserLinkDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementProfileUserLinkDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementProfileUserLinkDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementProfileUserLinkDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementProfileUserLinkDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6541,7 +6537,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkDeleteCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Account ID to delete the user link for. - pub fn account_id(mut self, new_value: &str) -> ManagementProfileUserLinkDeleteCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementProfileUserLinkDeleteCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -6551,7 +6547,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkDeleteCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Web Property ID to delete the user link for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileUserLinkDeleteCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileUserLinkDeleteCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -6561,7 +6557,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkDeleteCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// View (Profile) ID to delete the user link for. - pub fn profile_id(mut self, new_value: &str) -> ManagementProfileUserLinkDeleteCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementProfileUserLinkDeleteCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -6571,7 +6567,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkDeleteCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Link ID to delete the user link for. - pub fn link_id(mut self, new_value: &str) -> ManagementProfileUserLinkDeleteCall<'a, C, NC, A> { + pub fn link_id(mut self, new_value: &str) -> ManagementProfileUserLinkDeleteCall<'a, C, A> { self._link_id = new_value.to_string(); self } @@ -6582,7 +6578,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkDeleteCall<'a, C, NC, A> where NC: h /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileUserLinkDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileUserLinkDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6603,7 +6599,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkDeleteCall<'a, C, NC, A> where NC: h /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementProfileUserLinkDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementProfileUserLinkDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6620,7 +6616,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkDeleteCall<'a, C, NC, A> where NC: h /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementProfileUserLinkDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementProfileUserLinkDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6664,10 +6660,10 @@ impl<'a, C, NC, A> ManagementProfileUserLinkDeleteCall<'a, C, NC, A> where NC: h /// .doit(); /// # } /// ``` -pub struct ManagementProfileUserLinkUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementProfileUserLinkUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: EntityUserLink, _account_id: String, _web_property_id: String, @@ -6678,9 +6674,9 @@ pub struct ManagementProfileUserLinkUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementProfileUserLinkUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementProfileUserLinkUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementProfileUserLinkUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementProfileUserLinkUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6822,7 +6818,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkUpdateCall<'a, C, NC, A> where NC: h /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &EntityUserLink) -> ManagementProfileUserLinkUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &EntityUserLink) -> ManagementProfileUserLinkUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6832,7 +6828,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkUpdateCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Account ID to update the user link for. - pub fn account_id(mut self, new_value: &str) -> ManagementProfileUserLinkUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementProfileUserLinkUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -6842,7 +6838,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkUpdateCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Web Property ID to update the user link for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileUserLinkUpdateCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileUserLinkUpdateCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -6852,7 +6848,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkUpdateCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// View (Profile ID) to update the user link for. - pub fn profile_id(mut self, new_value: &str) -> ManagementProfileUserLinkUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementProfileUserLinkUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -6862,7 +6858,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkUpdateCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Link ID to update the user link for. - pub fn link_id(mut self, new_value: &str) -> ManagementProfileUserLinkUpdateCall<'a, C, NC, A> { + pub fn link_id(mut self, new_value: &str) -> ManagementProfileUserLinkUpdateCall<'a, C, A> { self._link_id = new_value.to_string(); self } @@ -6873,7 +6869,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkUpdateCall<'a, C, NC, A> where NC: h /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileUserLinkUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileUserLinkUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6894,7 +6890,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkUpdateCall<'a, C, NC, A> where NC: h /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementProfileUserLinkUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementProfileUserLinkUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6911,7 +6907,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkUpdateCall<'a, C, NC, A> where NC: h /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementProfileUserLinkUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementProfileUserLinkUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6955,10 +6951,10 @@ impl<'a, C, NC, A> ManagementProfileUserLinkUpdateCall<'a, C, NC, A> where NC: h /// .doit(); /// # } /// ``` -pub struct ManagementFilterInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementFilterInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: Filter, _account_id: String, _delegate: Option<&'a mut Delegate>, @@ -6966,9 +6962,9 @@ pub struct ManagementFilterInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementFilterInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementFilterInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementFilterInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementFilterInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7107,7 +7103,7 @@ impl<'a, C, NC, A> ManagementFilterInsertCall<'a, C, NC, A> where NC: hyper::net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Filter) -> ManagementFilterInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Filter) -> ManagementFilterInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7117,7 +7113,7 @@ impl<'a, C, NC, A> ManagementFilterInsertCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Account ID to create filter for. - pub fn account_id(mut self, new_value: &str) -> ManagementFilterInsertCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementFilterInsertCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -7128,7 +7124,7 @@ impl<'a, C, NC, A> ManagementFilterInsertCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementFilterInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementFilterInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7149,7 +7145,7 @@ impl<'a, C, NC, A> ManagementFilterInsertCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementFilterInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementFilterInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7166,7 +7162,7 @@ impl<'a, C, NC, A> ManagementFilterInsertCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementFilterInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementFilterInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7210,10 +7206,10 @@ impl<'a, C, NC, A> ManagementFilterInsertCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct ManagementAccountUserLinkUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementAccountUserLinkUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: EntityUserLink, _account_id: String, _link_id: String, @@ -7222,9 +7218,9 @@ pub struct ManagementAccountUserLinkUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementAccountUserLinkUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementAccountUserLinkUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementAccountUserLinkUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementAccountUserLinkUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7364,7 +7360,7 @@ impl<'a, C, NC, A> ManagementAccountUserLinkUpdateCall<'a, C, NC, A> where NC: h /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &EntityUserLink) -> ManagementAccountUserLinkUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &EntityUserLink) -> ManagementAccountUserLinkUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7374,7 +7370,7 @@ impl<'a, C, NC, A> ManagementAccountUserLinkUpdateCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Account ID to update the account-user link for. - pub fn account_id(mut self, new_value: &str) -> ManagementAccountUserLinkUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementAccountUserLinkUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -7384,7 +7380,7 @@ impl<'a, C, NC, A> ManagementAccountUserLinkUpdateCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Link ID to update the account-user link for. - pub fn link_id(mut self, new_value: &str) -> ManagementAccountUserLinkUpdateCall<'a, C, NC, A> { + pub fn link_id(mut self, new_value: &str) -> ManagementAccountUserLinkUpdateCall<'a, C, A> { self._link_id = new_value.to_string(); self } @@ -7395,7 +7391,7 @@ impl<'a, C, NC, A> ManagementAccountUserLinkUpdateCall<'a, C, NC, A> where NC: h /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementAccountUserLinkUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementAccountUserLinkUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7416,7 +7412,7 @@ impl<'a, C, NC, A> ManagementAccountUserLinkUpdateCall<'a, C, NC, A> where NC: h /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementAccountUserLinkUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementAccountUserLinkUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7433,7 +7429,7 @@ impl<'a, C, NC, A> ManagementAccountUserLinkUpdateCall<'a, C, NC, A> where NC: h /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementAccountUserLinkUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementAccountUserLinkUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7477,10 +7473,10 @@ impl<'a, C, NC, A> ManagementAccountUserLinkUpdateCall<'a, C, NC, A> where NC: h /// .doit(); /// # } /// ``` -pub struct ManagementWebpropertyUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementWebpropertyUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: Webproperty, _account_id: String, _web_property_id: String, @@ -7489,9 +7485,9 @@ pub struct ManagementWebpropertyUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementWebpropertyUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementWebpropertyUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementWebpropertyUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementWebpropertyUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7631,7 +7627,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUpdateCall<'a, C, NC, A> where NC: hyper /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Webproperty) -> ManagementWebpropertyUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Webproperty) -> ManagementWebpropertyUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7641,7 +7637,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUpdateCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// Account ID to which the web property belongs - pub fn account_id(mut self, new_value: &str) -> ManagementWebpropertyUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementWebpropertyUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -7651,7 +7647,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUpdateCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// Web property ID - pub fn web_property_id(mut self, new_value: &str) -> ManagementWebpropertyUpdateCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementWebpropertyUpdateCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -7662,7 +7658,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUpdateCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebpropertyUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebpropertyUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7683,7 +7679,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUpdateCall<'a, C, NC, A> where NC: hyper /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementWebpropertyUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementWebpropertyUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7700,7 +7696,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUpdateCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementWebpropertyUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementWebpropertyUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7744,10 +7740,10 @@ impl<'a, C, NC, A> ManagementWebpropertyUpdateCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct ManagementWebpropertyUserLinkUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementWebpropertyUserLinkUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: EntityUserLink, _account_id: String, _web_property_id: String, @@ -7757,9 +7753,9 @@ pub struct ManagementWebpropertyUserLinkUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementWebpropertyUserLinkUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementWebpropertyUserLinkUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementWebpropertyUserLinkUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementWebpropertyUserLinkUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7900,7 +7896,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkUpdateCall<'a, C, NC, A> where N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &EntityUserLink) -> ManagementWebpropertyUserLinkUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &EntityUserLink) -> ManagementWebpropertyUserLinkUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7910,7 +7906,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkUpdateCall<'a, C, NC, A> where N /// we provide this method for API completeness. /// /// Account ID to update the account-user link for. - pub fn account_id(mut self, new_value: &str) -> ManagementWebpropertyUserLinkUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementWebpropertyUserLinkUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -7920,7 +7916,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkUpdateCall<'a, C, NC, A> where N /// we provide this method for API completeness. /// /// Web property ID to update the account-user link for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementWebpropertyUserLinkUpdateCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementWebpropertyUserLinkUpdateCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -7930,7 +7926,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkUpdateCall<'a, C, NC, A> where N /// we provide this method for API completeness. /// /// Link ID to update the account-user link for. - pub fn link_id(mut self, new_value: &str) -> ManagementWebpropertyUserLinkUpdateCall<'a, C, NC, A> { + pub fn link_id(mut self, new_value: &str) -> ManagementWebpropertyUserLinkUpdateCall<'a, C, A> { self._link_id = new_value.to_string(); self } @@ -7941,7 +7937,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkUpdateCall<'a, C, NC, A> where N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebpropertyUserLinkUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebpropertyUserLinkUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7962,7 +7958,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkUpdateCall<'a, C, NC, A> where N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementWebpropertyUserLinkUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementWebpropertyUserLinkUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7979,7 +7975,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkUpdateCall<'a, C, NC, A> where N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementWebpropertyUserLinkUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementWebpropertyUserLinkUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8023,10 +8019,10 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkUpdateCall<'a, C, NC, A> where N /// .doit(); /// # } /// ``` -pub struct ManagementUnsampledReportInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementUnsampledReportInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: UnsampledReport, _account_id: String, _web_property_id: String, @@ -8036,9 +8032,9 @@ pub struct ManagementUnsampledReportInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementUnsampledReportInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementUnsampledReportInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementUnsampledReportInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementUnsampledReportInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8179,7 +8175,7 @@ impl<'a, C, NC, A> ManagementUnsampledReportInsertCall<'a, C, NC, A> where NC: h /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &UnsampledReport) -> ManagementUnsampledReportInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &UnsampledReport) -> ManagementUnsampledReportInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8189,7 +8185,7 @@ impl<'a, C, NC, A> ManagementUnsampledReportInsertCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Account ID to create the unsampled report for. - pub fn account_id(mut self, new_value: &str) -> ManagementUnsampledReportInsertCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementUnsampledReportInsertCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -8199,7 +8195,7 @@ impl<'a, C, NC, A> ManagementUnsampledReportInsertCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Web property ID to create the unsampled report for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementUnsampledReportInsertCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementUnsampledReportInsertCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -8209,7 +8205,7 @@ impl<'a, C, NC, A> ManagementUnsampledReportInsertCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// View (Profile) ID to create the unsampled report for. - pub fn profile_id(mut self, new_value: &str) -> ManagementUnsampledReportInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementUnsampledReportInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -8220,7 +8216,7 @@ impl<'a, C, NC, A> ManagementUnsampledReportInsertCall<'a, C, NC, A> where NC: h /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementUnsampledReportInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementUnsampledReportInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8241,7 +8237,7 @@ impl<'a, C, NC, A> ManagementUnsampledReportInsertCall<'a, C, NC, A> where NC: h /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementUnsampledReportInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementUnsampledReportInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8258,7 +8254,7 @@ impl<'a, C, NC, A> ManagementUnsampledReportInsertCall<'a, C, NC, A> where NC: h /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementUnsampledReportInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementUnsampledReportInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8296,10 +8292,10 @@ impl<'a, C, NC, A> ManagementUnsampledReportInsertCall<'a, C, NC, A> where NC: h /// .doit(); /// # } /// ``` -pub struct ManagementCustomMetricGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementCustomMetricGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _custom_metric_id: String, @@ -8308,9 +8304,9 @@ pub struct ManagementCustomMetricGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementCustomMetricGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementCustomMetricGetCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementCustomMetricGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementCustomMetricGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8444,7 +8440,7 @@ impl<'a, C, NC, A> ManagementCustomMetricGetCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Account ID for the custom metric to retrieve. - pub fn account_id(mut self, new_value: &str) -> ManagementCustomMetricGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementCustomMetricGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -8454,7 +8450,7 @@ impl<'a, C, NC, A> ManagementCustomMetricGetCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Web property ID for the custom metric to retrieve. - pub fn web_property_id(mut self, new_value: &str) -> ManagementCustomMetricGetCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementCustomMetricGetCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -8464,7 +8460,7 @@ impl<'a, C, NC, A> ManagementCustomMetricGetCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The ID of the custom metric to retrieve. - pub fn custom_metric_id(mut self, new_value: &str) -> ManagementCustomMetricGetCall<'a, C, NC, A> { + pub fn custom_metric_id(mut self, new_value: &str) -> ManagementCustomMetricGetCall<'a, C, A> { self._custom_metric_id = new_value.to_string(); self } @@ -8475,7 +8471,7 @@ impl<'a, C, NC, A> ManagementCustomMetricGetCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementCustomMetricGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementCustomMetricGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8496,7 +8492,7 @@ impl<'a, C, NC, A> ManagementCustomMetricGetCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementCustomMetricGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementCustomMetricGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8513,7 +8509,7 @@ impl<'a, C, NC, A> ManagementCustomMetricGetCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementCustomMetricGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementCustomMetricGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8551,10 +8547,10 @@ impl<'a, C, NC, A> ManagementCustomMetricGetCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct ManagementUploadGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementUploadGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _custom_data_source_id: String, @@ -8564,9 +8560,9 @@ pub struct ManagementUploadGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementUploadGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementUploadGetCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementUploadGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementUploadGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8701,7 +8697,7 @@ impl<'a, C, NC, A> ManagementUploadGetCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Account Id for the upload to retrieve. - pub fn account_id(mut self, new_value: &str) -> ManagementUploadGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementUploadGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -8711,7 +8707,7 @@ impl<'a, C, NC, A> ManagementUploadGetCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Web property Id for the upload to retrieve. - pub fn web_property_id(mut self, new_value: &str) -> ManagementUploadGetCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementUploadGetCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -8721,7 +8717,7 @@ impl<'a, C, NC, A> ManagementUploadGetCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Custom data source Id for upload to retrieve. - pub fn custom_data_source_id(mut self, new_value: &str) -> ManagementUploadGetCall<'a, C, NC, A> { + pub fn custom_data_source_id(mut self, new_value: &str) -> ManagementUploadGetCall<'a, C, A> { self._custom_data_source_id = new_value.to_string(); self } @@ -8731,7 +8727,7 @@ impl<'a, C, NC, A> ManagementUploadGetCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Upload Id to retrieve. - pub fn upload_id(mut self, new_value: &str) -> ManagementUploadGetCall<'a, C, NC, A> { + pub fn upload_id(mut self, new_value: &str) -> ManagementUploadGetCall<'a, C, A> { self._upload_id = new_value.to_string(); self } @@ -8742,7 +8738,7 @@ impl<'a, C, NC, A> ManagementUploadGetCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementUploadGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementUploadGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8763,7 +8759,7 @@ impl<'a, C, NC, A> ManagementUploadGetCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementUploadGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementUploadGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8780,7 +8776,7 @@ impl<'a, C, NC, A> ManagementUploadGetCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementUploadGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementUploadGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8818,10 +8814,10 @@ impl<'a, C, NC, A> ManagementUploadGetCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct ManagementWebPropertyAdWordsLinkGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementWebPropertyAdWordsLinkGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _web_property_ad_words_link_id: String, @@ -8830,9 +8826,9 @@ pub struct ManagementWebPropertyAdWordsLinkGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementWebPropertyAdWordsLinkGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementWebPropertyAdWordsLinkGetCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementWebPropertyAdWordsLinkGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8966,7 +8962,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkGetCall<'a, C, NC, A> where N /// we provide this method for API completeness. /// /// ID of the account which the given web property belongs to. - pub fn account_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -8976,7 +8972,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkGetCall<'a, C, NC, A> where N /// we provide this method for API completeness. /// /// Web property ID to retrieve the AdWords link for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkGetCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkGetCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -8986,7 +8982,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkGetCall<'a, C, NC, A> where N /// we provide this method for API completeness. /// /// Web property-AdWords link ID. - pub fn web_property_ad_words_link_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkGetCall<'a, C, NC, A> { + pub fn web_property_ad_words_link_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkGetCall<'a, C, A> { self._web_property_ad_words_link_id = new_value.to_string(); self } @@ -8997,7 +8993,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkGetCall<'a, C, NC, A> where N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebPropertyAdWordsLinkGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebPropertyAdWordsLinkGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9018,7 +9014,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkGetCall<'a, C, NC, A> where N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementWebPropertyAdWordsLinkGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementWebPropertyAdWordsLinkGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9035,7 +9031,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkGetCall<'a, C, NC, A> where N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementWebPropertyAdWordsLinkGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementWebPropertyAdWordsLinkGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9075,10 +9071,10 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkGetCall<'a, C, NC, A> where N /// .doit(); /// # } /// ``` -pub struct ManagementWebpropertyUserLinkListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementWebpropertyUserLinkListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _start_index: Option, @@ -9088,9 +9084,9 @@ pub struct ManagementWebpropertyUserLinkListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementWebpropertyUserLinkListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementWebpropertyUserLinkListCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementWebpropertyUserLinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementWebpropertyUserLinkListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9229,7 +9225,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkListCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Account ID which the given web property belongs to. - pub fn account_id(mut self, new_value: &str) -> ManagementWebpropertyUserLinkListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementWebpropertyUserLinkListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -9239,7 +9235,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkListCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Web Property ID for the webProperty-user links to retrieve. Can either be a specific web property ID or '~all', which refers to all the web properties that user has access to. - pub fn web_property_id(mut self, new_value: &str) -> ManagementWebpropertyUserLinkListCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementWebpropertyUserLinkListCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -9247,7 +9243,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkListCall<'a, C, NC, A> where NC: /// /// /// An index of the first webProperty-user link to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter. - pub fn start_index(mut self, new_value: i32) -> ManagementWebpropertyUserLinkListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> ManagementWebpropertyUserLinkListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -9255,7 +9251,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkListCall<'a, C, NC, A> where NC: /// /// /// The maximum number of webProperty-user Links to include in this response. - pub fn max_results(mut self, new_value: i32) -> ManagementWebpropertyUserLinkListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ManagementWebpropertyUserLinkListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -9266,7 +9262,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkListCall<'a, C, NC, A> where NC: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebpropertyUserLinkListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebpropertyUserLinkListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9287,7 +9283,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkListCall<'a, C, NC, A> where NC: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementWebpropertyUserLinkListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementWebpropertyUserLinkListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9304,7 +9300,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkListCall<'a, C, NC, A> where NC: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementWebpropertyUserLinkListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementWebpropertyUserLinkListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9348,10 +9344,10 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkListCall<'a, C, NC, A> where NC: /// .doit(); /// # } /// ``` -pub struct ManagementProfileFilterLinkUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementProfileFilterLinkUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: ProfileFilterLink, _account_id: String, _web_property_id: String, @@ -9362,9 +9358,9 @@ pub struct ManagementProfileFilterLinkUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementProfileFilterLinkUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementProfileFilterLinkUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementProfileFilterLinkUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementProfileFilterLinkUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9506,7 +9502,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkUpdateCall<'a, C, NC, A> where NC: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ProfileFilterLink) -> ManagementProfileFilterLinkUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ProfileFilterLink) -> ManagementProfileFilterLinkUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9516,7 +9512,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkUpdateCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Account ID to which profile filter link belongs. - pub fn account_id(mut self, new_value: &str) -> ManagementProfileFilterLinkUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementProfileFilterLinkUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -9526,7 +9522,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkUpdateCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Web property Id to which profile filter link belongs - pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileFilterLinkUpdateCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileFilterLinkUpdateCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -9536,7 +9532,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkUpdateCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Profile ID to which filter link belongs - pub fn profile_id(mut self, new_value: &str) -> ManagementProfileFilterLinkUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementProfileFilterLinkUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -9546,7 +9542,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkUpdateCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// ID of the profile filter link to be updated. - pub fn link_id(mut self, new_value: &str) -> ManagementProfileFilterLinkUpdateCall<'a, C, NC, A> { + pub fn link_id(mut self, new_value: &str) -> ManagementProfileFilterLinkUpdateCall<'a, C, A> { self._link_id = new_value.to_string(); self } @@ -9557,7 +9553,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkUpdateCall<'a, C, NC, A> where NC: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileFilterLinkUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileFilterLinkUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9578,7 +9574,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkUpdateCall<'a, C, NC, A> where NC: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementProfileFilterLinkUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementProfileFilterLinkUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9595,7 +9591,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkUpdateCall<'a, C, NC, A> where NC: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementProfileFilterLinkUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementProfileFilterLinkUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9633,10 +9629,10 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkUpdateCall<'a, C, NC, A> where NC: /// .doit(); /// # } /// ``` -pub struct ManagementExperimentGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementExperimentGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _profile_id: String, @@ -9646,9 +9642,9 @@ pub struct ManagementExperimentGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementExperimentGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementExperimentGetCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementExperimentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementExperimentGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9783,7 +9779,7 @@ impl<'a, C, NC, A> ManagementExperimentGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Account ID to retrieve the experiment for. - pub fn account_id(mut self, new_value: &str) -> ManagementExperimentGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementExperimentGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -9793,7 +9789,7 @@ impl<'a, C, NC, A> ManagementExperimentGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Web property ID to retrieve the experiment for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementExperimentGetCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementExperimentGetCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -9803,7 +9799,7 @@ impl<'a, C, NC, A> ManagementExperimentGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// View (Profile) ID to retrieve the experiment for. - pub fn profile_id(mut self, new_value: &str) -> ManagementExperimentGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementExperimentGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -9813,7 +9809,7 @@ impl<'a, C, NC, A> ManagementExperimentGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Experiment ID to retrieve the experiment for. - pub fn experiment_id(mut self, new_value: &str) -> ManagementExperimentGetCall<'a, C, NC, A> { + pub fn experiment_id(mut self, new_value: &str) -> ManagementExperimentGetCall<'a, C, A> { self._experiment_id = new_value.to_string(); self } @@ -9824,7 +9820,7 @@ impl<'a, C, NC, A> ManagementExperimentGetCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementExperimentGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementExperimentGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9845,7 +9841,7 @@ impl<'a, C, NC, A> ManagementExperimentGetCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementExperimentGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementExperimentGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9862,7 +9858,7 @@ impl<'a, C, NC, A> ManagementExperimentGetCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementExperimentGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementExperimentGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9907,10 +9903,10 @@ impl<'a, C, NC, A> ManagementExperimentGetCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct ManagementCustomDimensionUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementCustomDimensionUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: CustomDimension, _account_id: String, _web_property_id: String, @@ -9921,9 +9917,9 @@ pub struct ManagementCustomDimensionUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementCustomDimensionUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementCustomDimensionUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementCustomDimensionUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementCustomDimensionUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10067,7 +10063,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionUpdateCall<'a, C, NC, A> where NC: h /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CustomDimension) -> ManagementCustomDimensionUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CustomDimension) -> ManagementCustomDimensionUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -10077,7 +10073,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionUpdateCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Account ID for the custom dimension to update. - pub fn account_id(mut self, new_value: &str) -> ManagementCustomDimensionUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementCustomDimensionUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -10087,7 +10083,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionUpdateCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Web property ID for the custom dimension to update. - pub fn web_property_id(mut self, new_value: &str) -> ManagementCustomDimensionUpdateCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementCustomDimensionUpdateCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -10097,7 +10093,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionUpdateCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Custom dimension ID for the custom dimension to update. - pub fn custom_dimension_id(mut self, new_value: &str) -> ManagementCustomDimensionUpdateCall<'a, C, NC, A> { + pub fn custom_dimension_id(mut self, new_value: &str) -> ManagementCustomDimensionUpdateCall<'a, C, A> { self._custom_dimension_id = new_value.to_string(); self } @@ -10105,7 +10101,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionUpdateCall<'a, C, NC, A> where NC: h /// /// /// Force the update and ignore any warnings related to the custom dimension being linked to a custom data source / data set. - pub fn ignore_custom_data_source_links(mut self, new_value: bool) -> ManagementCustomDimensionUpdateCall<'a, C, NC, A> { + pub fn ignore_custom_data_source_links(mut self, new_value: bool) -> ManagementCustomDimensionUpdateCall<'a, C, A> { self._ignore_custom_data_source_links = Some(new_value); self } @@ -10116,7 +10112,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionUpdateCall<'a, C, NC, A> where NC: h /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementCustomDimensionUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementCustomDimensionUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10137,7 +10133,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionUpdateCall<'a, C, NC, A> where NC: h /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementCustomDimensionUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementCustomDimensionUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10154,7 +10150,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionUpdateCall<'a, C, NC, A> where NC: h /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementCustomDimensionUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementCustomDimensionUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10192,10 +10188,10 @@ impl<'a, C, NC, A> ManagementCustomDimensionUpdateCall<'a, C, NC, A> where NC: h /// .doit(); /// # } /// ``` -pub struct ManagementUnsampledReportGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementUnsampledReportGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _profile_id: String, @@ -10205,9 +10201,9 @@ pub struct ManagementUnsampledReportGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementUnsampledReportGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementUnsampledReportGetCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementUnsampledReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementUnsampledReportGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10342,7 +10338,7 @@ impl<'a, C, NC, A> ManagementUnsampledReportGetCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// Account ID to retrieve unsampled report for. - pub fn account_id(mut self, new_value: &str) -> ManagementUnsampledReportGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementUnsampledReportGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -10352,7 +10348,7 @@ impl<'a, C, NC, A> ManagementUnsampledReportGetCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// Web property ID to retrieve unsampled reports for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementUnsampledReportGetCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementUnsampledReportGetCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -10362,7 +10358,7 @@ impl<'a, C, NC, A> ManagementUnsampledReportGetCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// View (Profile) ID to retrieve unsampled report for. - pub fn profile_id(mut self, new_value: &str) -> ManagementUnsampledReportGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementUnsampledReportGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -10372,7 +10368,7 @@ impl<'a, C, NC, A> ManagementUnsampledReportGetCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// ID of the unsampled report to retrieve. - pub fn unsampled_report_id(mut self, new_value: &str) -> ManagementUnsampledReportGetCall<'a, C, NC, A> { + pub fn unsampled_report_id(mut self, new_value: &str) -> ManagementUnsampledReportGetCall<'a, C, A> { self._unsampled_report_id = new_value.to_string(); self } @@ -10383,7 +10379,7 @@ impl<'a, C, NC, A> ManagementUnsampledReportGetCall<'a, C, NC, A> where NC: hype /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementUnsampledReportGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementUnsampledReportGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10404,7 +10400,7 @@ impl<'a, C, NC, A> ManagementUnsampledReportGetCall<'a, C, NC, A> where NC: hype /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementUnsampledReportGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementUnsampledReportGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10421,7 +10417,7 @@ impl<'a, C, NC, A> ManagementUnsampledReportGetCall<'a, C, NC, A> where NC: hype /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementUnsampledReportGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementUnsampledReportGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10465,10 +10461,10 @@ impl<'a, C, NC, A> ManagementUnsampledReportGetCall<'a, C, NC, A> where NC: hype /// .doit(); /// # } /// ``` -pub struct ManagementProfileFilterLinkInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementProfileFilterLinkInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: ProfileFilterLink, _account_id: String, _web_property_id: String, @@ -10478,9 +10474,9 @@ pub struct ManagementProfileFilterLinkInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementProfileFilterLinkInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementProfileFilterLinkInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementProfileFilterLinkInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementProfileFilterLinkInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10621,7 +10617,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkInsertCall<'a, C, NC, A> where NC: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ProfileFilterLink) -> ManagementProfileFilterLinkInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ProfileFilterLink) -> ManagementProfileFilterLinkInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -10631,7 +10627,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkInsertCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Account ID to create profile filter link for. - pub fn account_id(mut self, new_value: &str) -> ManagementProfileFilterLinkInsertCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementProfileFilterLinkInsertCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -10641,7 +10637,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkInsertCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Web property Id to create profile filter link for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileFilterLinkInsertCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileFilterLinkInsertCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -10651,7 +10647,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkInsertCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Profile ID to create filter link for. - pub fn profile_id(mut self, new_value: &str) -> ManagementProfileFilterLinkInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementProfileFilterLinkInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -10662,7 +10658,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkInsertCall<'a, C, NC, A> where NC: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileFilterLinkInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileFilterLinkInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10683,7 +10679,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkInsertCall<'a, C, NC, A> where NC: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementProfileFilterLinkInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementProfileFilterLinkInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10700,7 +10696,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkInsertCall<'a, C, NC, A> where NC: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementProfileFilterLinkInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementProfileFilterLinkInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10744,10 +10740,10 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkInsertCall<'a, C, NC, A> where NC: /// .doit(); /// # } /// ``` -pub struct ManagementFilterUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementFilterUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: Filter, _account_id: String, _filter_id: String, @@ -10756,9 +10752,9 @@ pub struct ManagementFilterUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementFilterUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementFilterUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementFilterUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementFilterUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10898,7 +10894,7 @@ impl<'a, C, NC, A> ManagementFilterUpdateCall<'a, C, NC, A> where NC: hyper::net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Filter) -> ManagementFilterUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Filter) -> ManagementFilterUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -10908,7 +10904,7 @@ impl<'a, C, NC, A> ManagementFilterUpdateCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Account ID to which the filter belongs. - pub fn account_id(mut self, new_value: &str) -> ManagementFilterUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementFilterUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -10918,7 +10914,7 @@ impl<'a, C, NC, A> ManagementFilterUpdateCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// ID of the filter to be updated. - pub fn filter_id(mut self, new_value: &str) -> ManagementFilterUpdateCall<'a, C, NC, A> { + pub fn filter_id(mut self, new_value: &str) -> ManagementFilterUpdateCall<'a, C, A> { self._filter_id = new_value.to_string(); self } @@ -10929,7 +10925,7 @@ impl<'a, C, NC, A> ManagementFilterUpdateCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementFilterUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementFilterUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10950,7 +10946,7 @@ impl<'a, C, NC, A> ManagementFilterUpdateCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementFilterUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementFilterUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10967,7 +10963,7 @@ impl<'a, C, NC, A> ManagementFilterUpdateCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementFilterUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementFilterUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11005,10 +11001,10 @@ impl<'a, C, NC, A> ManagementFilterUpdateCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct ManagementProfileFilterLinkDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementProfileFilterLinkDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _profile_id: String, @@ -11018,9 +11014,9 @@ pub struct ManagementProfileFilterLinkDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementProfileFilterLinkDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementProfileFilterLinkDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementProfileFilterLinkDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementProfileFilterLinkDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11144,7 +11140,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkDeleteCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Account ID to which the profile filter link belongs. - pub fn account_id(mut self, new_value: &str) -> ManagementProfileFilterLinkDeleteCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementProfileFilterLinkDeleteCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -11154,7 +11150,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkDeleteCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Web property Id to which the profile filter link belongs. - pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileFilterLinkDeleteCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileFilterLinkDeleteCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -11164,7 +11160,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkDeleteCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Profile ID to which the filter link belongs. - pub fn profile_id(mut self, new_value: &str) -> ManagementProfileFilterLinkDeleteCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementProfileFilterLinkDeleteCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -11174,7 +11170,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkDeleteCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// ID of the profile filter link to delete. - pub fn link_id(mut self, new_value: &str) -> ManagementProfileFilterLinkDeleteCall<'a, C, NC, A> { + pub fn link_id(mut self, new_value: &str) -> ManagementProfileFilterLinkDeleteCall<'a, C, A> { self._link_id = new_value.to_string(); self } @@ -11185,7 +11181,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkDeleteCall<'a, C, NC, A> where NC: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileFilterLinkDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileFilterLinkDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11206,7 +11202,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkDeleteCall<'a, C, NC, A> where NC: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementProfileFilterLinkDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementProfileFilterLinkDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11223,7 +11219,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkDeleteCall<'a, C, NC, A> where NC: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementProfileFilterLinkDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementProfileFilterLinkDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11263,10 +11259,10 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkDeleteCall<'a, C, NC, A> where NC: /// .doit(); /// # } /// ``` -pub struct ManagementSegmentListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementSegmentListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _start_index: Option, _max_results: Option, _delegate: Option<&'a mut Delegate>, @@ -11274,9 +11270,9 @@ pub struct ManagementSegmentListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementSegmentListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementSegmentListCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementSegmentListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementSegmentListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11387,7 +11383,7 @@ impl<'a, C, NC, A> ManagementSegmentListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// An index of the first segment to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter. - pub fn start_index(mut self, new_value: i32) -> ManagementSegmentListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> ManagementSegmentListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -11395,7 +11391,7 @@ impl<'a, C, NC, A> ManagementSegmentListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// The maximum number of segments to include in this response. - pub fn max_results(mut self, new_value: i32) -> ManagementSegmentListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ManagementSegmentListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -11406,7 +11402,7 @@ impl<'a, C, NC, A> ManagementSegmentListCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementSegmentListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementSegmentListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11427,7 +11423,7 @@ impl<'a, C, NC, A> ManagementSegmentListCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementSegmentListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementSegmentListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11444,7 +11440,7 @@ impl<'a, C, NC, A> ManagementSegmentListCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementSegmentListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementSegmentListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11482,10 +11478,10 @@ impl<'a, C, NC, A> ManagementSegmentListCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct ManagementProfileDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementProfileDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _profile_id: String, @@ -11494,9 +11490,9 @@ pub struct ManagementProfileDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementProfileDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementProfileDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementProfileDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementProfileDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11619,7 +11615,7 @@ impl<'a, C, NC, A> ManagementProfileDeleteCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Account ID to delete the view (profile) for. - pub fn account_id(mut self, new_value: &str) -> ManagementProfileDeleteCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementProfileDeleteCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -11629,7 +11625,7 @@ impl<'a, C, NC, A> ManagementProfileDeleteCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Web property ID to delete the view (profile) for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileDeleteCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileDeleteCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -11639,7 +11635,7 @@ impl<'a, C, NC, A> ManagementProfileDeleteCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// ID of the view (profile) to be deleted. - pub fn profile_id(mut self, new_value: &str) -> ManagementProfileDeleteCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementProfileDeleteCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -11650,7 +11646,7 @@ impl<'a, C, NC, A> ManagementProfileDeleteCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11671,7 +11667,7 @@ impl<'a, C, NC, A> ManagementProfileDeleteCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementProfileDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementProfileDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11688,7 +11684,7 @@ impl<'a, C, NC, A> ManagementProfileDeleteCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementProfileDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementProfileDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11732,10 +11728,10 @@ impl<'a, C, NC, A> ManagementProfileDeleteCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct ManagementGoalPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementGoalPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: Goal, _account_id: String, _web_property_id: String, @@ -11746,9 +11742,9 @@ pub struct ManagementGoalPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementGoalPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementGoalPatchCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementGoalPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementGoalPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11890,7 +11886,7 @@ impl<'a, C, NC, A> ManagementGoalPatchCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Goal) -> ManagementGoalPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Goal) -> ManagementGoalPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -11900,7 +11896,7 @@ impl<'a, C, NC, A> ManagementGoalPatchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Account ID to update the goal. - pub fn account_id(mut self, new_value: &str) -> ManagementGoalPatchCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementGoalPatchCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -11910,7 +11906,7 @@ impl<'a, C, NC, A> ManagementGoalPatchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Web property ID to update the goal. - pub fn web_property_id(mut self, new_value: &str) -> ManagementGoalPatchCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementGoalPatchCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -11920,7 +11916,7 @@ impl<'a, C, NC, A> ManagementGoalPatchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// View (Profile) ID to update the goal. - pub fn profile_id(mut self, new_value: &str) -> ManagementGoalPatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementGoalPatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -11930,7 +11926,7 @@ impl<'a, C, NC, A> ManagementGoalPatchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Index of the goal to be updated. - pub fn goal_id(mut self, new_value: &str) -> ManagementGoalPatchCall<'a, C, NC, A> { + pub fn goal_id(mut self, new_value: &str) -> ManagementGoalPatchCall<'a, C, A> { self._goal_id = new_value.to_string(); self } @@ -11941,7 +11937,7 @@ impl<'a, C, NC, A> ManagementGoalPatchCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementGoalPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementGoalPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11962,7 +11958,7 @@ impl<'a, C, NC, A> ManagementGoalPatchCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementGoalPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementGoalPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11979,7 +11975,7 @@ impl<'a, C, NC, A> ManagementGoalPatchCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementGoalPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementGoalPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12024,10 +12020,10 @@ impl<'a, C, NC, A> ManagementGoalPatchCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct ManagementCustomDimensionPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementCustomDimensionPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: CustomDimension, _account_id: String, _web_property_id: String, @@ -12038,9 +12034,9 @@ pub struct ManagementCustomDimensionPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementCustomDimensionPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementCustomDimensionPatchCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementCustomDimensionPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementCustomDimensionPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12184,7 +12180,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionPatchCall<'a, C, NC, A> where NC: hy /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CustomDimension) -> ManagementCustomDimensionPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CustomDimension) -> ManagementCustomDimensionPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -12194,7 +12190,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionPatchCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// Account ID for the custom dimension to update. - pub fn account_id(mut self, new_value: &str) -> ManagementCustomDimensionPatchCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementCustomDimensionPatchCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -12204,7 +12200,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionPatchCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// Web property ID for the custom dimension to update. - pub fn web_property_id(mut self, new_value: &str) -> ManagementCustomDimensionPatchCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementCustomDimensionPatchCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -12214,7 +12210,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionPatchCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// Custom dimension ID for the custom dimension to update. - pub fn custom_dimension_id(mut self, new_value: &str) -> ManagementCustomDimensionPatchCall<'a, C, NC, A> { + pub fn custom_dimension_id(mut self, new_value: &str) -> ManagementCustomDimensionPatchCall<'a, C, A> { self._custom_dimension_id = new_value.to_string(); self } @@ -12222,7 +12218,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionPatchCall<'a, C, NC, A> where NC: hy /// /// /// Force the update and ignore any warnings related to the custom dimension being linked to a custom data source / data set. - pub fn ignore_custom_data_source_links(mut self, new_value: bool) -> ManagementCustomDimensionPatchCall<'a, C, NC, A> { + pub fn ignore_custom_data_source_links(mut self, new_value: bool) -> ManagementCustomDimensionPatchCall<'a, C, A> { self._ignore_custom_data_source_links = Some(new_value); self } @@ -12233,7 +12229,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionPatchCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementCustomDimensionPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementCustomDimensionPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12254,7 +12250,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionPatchCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementCustomDimensionPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementCustomDimensionPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12271,7 +12267,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionPatchCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementCustomDimensionPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementCustomDimensionPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12315,10 +12311,10 @@ impl<'a, C, NC, A> ManagementCustomDimensionPatchCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct ManagementExperimentPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementExperimentPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: Experiment, _account_id: String, _web_property_id: String, @@ -12329,9 +12325,9 @@ pub struct ManagementExperimentPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementExperimentPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementExperimentPatchCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementExperimentPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementExperimentPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12473,7 +12469,7 @@ impl<'a, C, NC, A> ManagementExperimentPatchCall<'a, C, NC, A> where NC: hyper:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Experiment) -> ManagementExperimentPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Experiment) -> ManagementExperimentPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -12483,7 +12479,7 @@ impl<'a, C, NC, A> ManagementExperimentPatchCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Account ID of the experiment to update. - pub fn account_id(mut self, new_value: &str) -> ManagementExperimentPatchCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementExperimentPatchCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -12493,7 +12489,7 @@ impl<'a, C, NC, A> ManagementExperimentPatchCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Web property ID of the experiment to update. - pub fn web_property_id(mut self, new_value: &str) -> ManagementExperimentPatchCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementExperimentPatchCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -12503,7 +12499,7 @@ impl<'a, C, NC, A> ManagementExperimentPatchCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// View (Profile) ID of the experiment to update. - pub fn profile_id(mut self, new_value: &str) -> ManagementExperimentPatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementExperimentPatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -12513,7 +12509,7 @@ impl<'a, C, NC, A> ManagementExperimentPatchCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Experiment ID of the experiment to update. - pub fn experiment_id(mut self, new_value: &str) -> ManagementExperimentPatchCall<'a, C, NC, A> { + pub fn experiment_id(mut self, new_value: &str) -> ManagementExperimentPatchCall<'a, C, A> { self._experiment_id = new_value.to_string(); self } @@ -12524,7 +12520,7 @@ impl<'a, C, NC, A> ManagementExperimentPatchCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementExperimentPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementExperimentPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12545,7 +12541,7 @@ impl<'a, C, NC, A> ManagementExperimentPatchCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementExperimentPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementExperimentPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12562,7 +12558,7 @@ impl<'a, C, NC, A> ManagementExperimentPatchCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementExperimentPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementExperimentPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12602,10 +12598,10 @@ impl<'a, C, NC, A> ManagementExperimentPatchCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct ManagementExperimentListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementExperimentListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _profile_id: String, @@ -12616,9 +12612,9 @@ pub struct ManagementExperimentListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementExperimentListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementExperimentListCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementExperimentListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementExperimentListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12758,7 +12754,7 @@ impl<'a, C, NC, A> ManagementExperimentListCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Account ID to retrieve experiments for. - pub fn account_id(mut self, new_value: &str) -> ManagementExperimentListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementExperimentListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -12768,7 +12764,7 @@ impl<'a, C, NC, A> ManagementExperimentListCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Web property ID to retrieve experiments for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementExperimentListCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementExperimentListCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -12778,7 +12774,7 @@ impl<'a, C, NC, A> ManagementExperimentListCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// View (Profile) ID to retrieve experiments for. - pub fn profile_id(mut self, new_value: &str) -> ManagementExperimentListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementExperimentListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -12786,7 +12782,7 @@ impl<'a, C, NC, A> ManagementExperimentListCall<'a, C, NC, A> where NC: hyper::n /// /// /// An index of the first experiment to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter. - pub fn start_index(mut self, new_value: i32) -> ManagementExperimentListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> ManagementExperimentListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -12794,7 +12790,7 @@ impl<'a, C, NC, A> ManagementExperimentListCall<'a, C, NC, A> where NC: hyper::n /// /// /// The maximum number of experiments to include in this response. - pub fn max_results(mut self, new_value: i32) -> ManagementExperimentListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ManagementExperimentListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -12805,7 +12801,7 @@ impl<'a, C, NC, A> ManagementExperimentListCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementExperimentListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementExperimentListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12826,7 +12822,7 @@ impl<'a, C, NC, A> ManagementExperimentListCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementExperimentListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementExperimentListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12843,7 +12839,7 @@ impl<'a, C, NC, A> ManagementExperimentListCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementExperimentListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementExperimentListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12883,10 +12879,10 @@ impl<'a, C, NC, A> ManagementExperimentListCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct ManagementProfileListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementProfileListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _start_index: Option, @@ -12896,9 +12892,9 @@ pub struct ManagementProfileListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementProfileListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementProfileListCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementProfileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementProfileListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13037,7 +13033,7 @@ impl<'a, C, NC, A> ManagementProfileListCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Account ID for the view (profiles) to retrieve. Can either be a specific account ID or '~all', which refers to all the accounts to which the user has access. - pub fn account_id(mut self, new_value: &str) -> ManagementProfileListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementProfileListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -13047,7 +13043,7 @@ impl<'a, C, NC, A> ManagementProfileListCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Web property ID for the views (profiles) to retrieve. Can either be a specific web property ID or '~all', which refers to all the web properties to which the user has access. - pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileListCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileListCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -13055,7 +13051,7 @@ impl<'a, C, NC, A> ManagementProfileListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// An index of the first entity to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter. - pub fn start_index(mut self, new_value: i32) -> ManagementProfileListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> ManagementProfileListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -13063,7 +13059,7 @@ impl<'a, C, NC, A> ManagementProfileListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// The maximum number of views (profiles) to include in this response. - pub fn max_results(mut self, new_value: i32) -> ManagementProfileListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ManagementProfileListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -13074,7 +13070,7 @@ impl<'a, C, NC, A> ManagementProfileListCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13095,7 +13091,7 @@ impl<'a, C, NC, A> ManagementProfileListCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementProfileListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementProfileListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13112,7 +13108,7 @@ impl<'a, C, NC, A> ManagementProfileListCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementProfileListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementProfileListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13152,10 +13148,10 @@ impl<'a, C, NC, A> ManagementProfileListCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct ManagementGoalListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementGoalListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _profile_id: String, @@ -13166,9 +13162,9 @@ pub struct ManagementGoalListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementGoalListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementGoalListCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementGoalListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementGoalListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13308,7 +13304,7 @@ impl<'a, C, NC, A> ManagementGoalListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Account ID to retrieve goals for. Can either be a specific account ID or '~all', which refers to all the accounts that user has access to. - pub fn account_id(mut self, new_value: &str) -> ManagementGoalListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementGoalListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -13318,7 +13314,7 @@ impl<'a, C, NC, A> ManagementGoalListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Web property ID to retrieve goals for. Can either be a specific web property ID or '~all', which refers to all the web properties that user has access to. - pub fn web_property_id(mut self, new_value: &str) -> ManagementGoalListCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementGoalListCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -13328,7 +13324,7 @@ impl<'a, C, NC, A> ManagementGoalListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// View (Profile) ID to retrieve goals for. Can either be a specific view (profile) ID or '~all', which refers to all the views (profiles) that user has access to. - pub fn profile_id(mut self, new_value: &str) -> ManagementGoalListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementGoalListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -13336,7 +13332,7 @@ impl<'a, C, NC, A> ManagementGoalListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// An index of the first goal to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter. - pub fn start_index(mut self, new_value: i32) -> ManagementGoalListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> ManagementGoalListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -13344,7 +13340,7 @@ impl<'a, C, NC, A> ManagementGoalListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// The maximum number of goals to include in this response. - pub fn max_results(mut self, new_value: i32) -> ManagementGoalListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ManagementGoalListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -13355,7 +13351,7 @@ impl<'a, C, NC, A> ManagementGoalListCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementGoalListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementGoalListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13376,7 +13372,7 @@ impl<'a, C, NC, A> ManagementGoalListCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementGoalListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementGoalListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13393,7 +13389,7 @@ impl<'a, C, NC, A> ManagementGoalListCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementGoalListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementGoalListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13437,10 +13433,10 @@ impl<'a, C, NC, A> ManagementGoalListCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct ManagementGoalInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementGoalInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: Goal, _account_id: String, _web_property_id: String, @@ -13450,9 +13446,9 @@ pub struct ManagementGoalInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementGoalInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementGoalInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementGoalInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementGoalInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13593,7 +13589,7 @@ impl<'a, C, NC, A> ManagementGoalInsertCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Goal) -> ManagementGoalInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Goal) -> ManagementGoalInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13603,7 +13599,7 @@ impl<'a, C, NC, A> ManagementGoalInsertCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Account ID to create the goal for. - pub fn account_id(mut self, new_value: &str) -> ManagementGoalInsertCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementGoalInsertCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -13613,7 +13609,7 @@ impl<'a, C, NC, A> ManagementGoalInsertCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Web property ID to create the goal for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementGoalInsertCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementGoalInsertCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -13623,7 +13619,7 @@ impl<'a, C, NC, A> ManagementGoalInsertCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// View (Profile) ID to create the goal for. - pub fn profile_id(mut self, new_value: &str) -> ManagementGoalInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementGoalInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -13634,7 +13630,7 @@ impl<'a, C, NC, A> ManagementGoalInsertCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementGoalInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementGoalInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13655,7 +13651,7 @@ impl<'a, C, NC, A> ManagementGoalInsertCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementGoalInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementGoalInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13672,7 +13668,7 @@ impl<'a, C, NC, A> ManagementGoalInsertCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementGoalInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementGoalInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13717,10 +13713,10 @@ impl<'a, C, NC, A> ManagementGoalInsertCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct ManagementCustomMetricPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementCustomMetricPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: CustomMetric, _account_id: String, _web_property_id: String, @@ -13731,9 +13727,9 @@ pub struct ManagementCustomMetricPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementCustomMetricPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementCustomMetricPatchCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementCustomMetricPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementCustomMetricPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13877,7 +13873,7 @@ impl<'a, C, NC, A> ManagementCustomMetricPatchCall<'a, C, NC, A> where NC: hyper /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CustomMetric) -> ManagementCustomMetricPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CustomMetric) -> ManagementCustomMetricPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13887,7 +13883,7 @@ impl<'a, C, NC, A> ManagementCustomMetricPatchCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// Account ID for the custom metric to update. - pub fn account_id(mut self, new_value: &str) -> ManagementCustomMetricPatchCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementCustomMetricPatchCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -13897,7 +13893,7 @@ impl<'a, C, NC, A> ManagementCustomMetricPatchCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// Web property ID for the custom metric to update. - pub fn web_property_id(mut self, new_value: &str) -> ManagementCustomMetricPatchCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementCustomMetricPatchCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -13907,7 +13903,7 @@ impl<'a, C, NC, A> ManagementCustomMetricPatchCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// Custom metric ID for the custom metric to update. - pub fn custom_metric_id(mut self, new_value: &str) -> ManagementCustomMetricPatchCall<'a, C, NC, A> { + pub fn custom_metric_id(mut self, new_value: &str) -> ManagementCustomMetricPatchCall<'a, C, A> { self._custom_metric_id = new_value.to_string(); self } @@ -13915,7 +13911,7 @@ impl<'a, C, NC, A> ManagementCustomMetricPatchCall<'a, C, NC, A> where NC: hyper /// /// /// Force the update and ignore any warnings related to the custom metric being linked to a custom data source / data set. - pub fn ignore_custom_data_source_links(mut self, new_value: bool) -> ManagementCustomMetricPatchCall<'a, C, NC, A> { + pub fn ignore_custom_data_source_links(mut self, new_value: bool) -> ManagementCustomMetricPatchCall<'a, C, A> { self._ignore_custom_data_source_links = Some(new_value); self } @@ -13926,7 +13922,7 @@ impl<'a, C, NC, A> ManagementCustomMetricPatchCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementCustomMetricPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementCustomMetricPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13947,7 +13943,7 @@ impl<'a, C, NC, A> ManagementCustomMetricPatchCall<'a, C, NC, A> where NC: hyper /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementCustomMetricPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementCustomMetricPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13964,7 +13960,7 @@ impl<'a, C, NC, A> ManagementCustomMetricPatchCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementCustomMetricPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementCustomMetricPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14003,10 +13999,10 @@ impl<'a, C, NC, A> ManagementCustomMetricPatchCall<'a, C, NC, A> where NC: hyper /// .upload_resumable(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct ManagementUploadUploadDataCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementUploadUploadDataCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _custom_data_source_id: String, @@ -14015,9 +14011,9 @@ pub struct ManagementUploadUploadDataCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementUploadUploadDataCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementUploadUploadDataCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementUploadUploadDataCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementUploadUploadDataCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14260,7 +14256,7 @@ impl<'a, C, NC, A> ManagementUploadUploadDataCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Account Id associated with the upload. - pub fn account_id(mut self, new_value: &str) -> ManagementUploadUploadDataCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementUploadUploadDataCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -14270,7 +14266,7 @@ impl<'a, C, NC, A> ManagementUploadUploadDataCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Web property UA-string associated with the upload. - pub fn web_property_id(mut self, new_value: &str) -> ManagementUploadUploadDataCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementUploadUploadDataCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -14280,7 +14276,7 @@ impl<'a, C, NC, A> ManagementUploadUploadDataCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Custom data source Id to which the data being uploaded belongs. - pub fn custom_data_source_id(mut self, new_value: &str) -> ManagementUploadUploadDataCall<'a, C, NC, A> { + pub fn custom_data_source_id(mut self, new_value: &str) -> ManagementUploadUploadDataCall<'a, C, A> { self._custom_data_source_id = new_value.to_string(); self } @@ -14291,7 +14287,7 @@ impl<'a, C, NC, A> ManagementUploadUploadDataCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementUploadUploadDataCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementUploadUploadDataCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14312,7 +14308,7 @@ impl<'a, C, NC, A> ManagementUploadUploadDataCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementUploadUploadDataCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementUploadUploadDataCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14329,7 +14325,7 @@ impl<'a, C, NC, A> ManagementUploadUploadDataCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementUploadUploadDataCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementUploadUploadDataCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14373,10 +14369,10 @@ impl<'a, C, NC, A> ManagementUploadUploadDataCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct ManagementAccountUserLinkInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementAccountUserLinkInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: EntityUserLink, _account_id: String, _delegate: Option<&'a mut Delegate>, @@ -14384,9 +14380,9 @@ pub struct ManagementAccountUserLinkInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementAccountUserLinkInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementAccountUserLinkInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementAccountUserLinkInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementAccountUserLinkInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14525,7 +14521,7 @@ impl<'a, C, NC, A> ManagementAccountUserLinkInsertCall<'a, C, NC, A> where NC: h /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &EntityUserLink) -> ManagementAccountUserLinkInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &EntityUserLink) -> ManagementAccountUserLinkInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -14535,7 +14531,7 @@ impl<'a, C, NC, A> ManagementAccountUserLinkInsertCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Account ID to create the user link for. - pub fn account_id(mut self, new_value: &str) -> ManagementAccountUserLinkInsertCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementAccountUserLinkInsertCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -14546,7 +14542,7 @@ impl<'a, C, NC, A> ManagementAccountUserLinkInsertCall<'a, C, NC, A> where NC: h /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementAccountUserLinkInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementAccountUserLinkInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14567,7 +14563,7 @@ impl<'a, C, NC, A> ManagementAccountUserLinkInsertCall<'a, C, NC, A> where NC: h /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementAccountUserLinkInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementAccountUserLinkInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14584,7 +14580,7 @@ impl<'a, C, NC, A> ManagementAccountUserLinkInsertCall<'a, C, NC, A> where NC: h /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementAccountUserLinkInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementAccountUserLinkInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14628,10 +14624,10 @@ impl<'a, C, NC, A> ManagementAccountUserLinkInsertCall<'a, C, NC, A> where NC: h /// .doit(); /// # } /// ``` -pub struct ManagementWebpropertyUserLinkInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementWebpropertyUserLinkInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: EntityUserLink, _account_id: String, _web_property_id: String, @@ -14640,9 +14636,9 @@ pub struct ManagementWebpropertyUserLinkInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementWebpropertyUserLinkInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementWebpropertyUserLinkInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementWebpropertyUserLinkInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementWebpropertyUserLinkInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14782,7 +14778,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkInsertCall<'a, C, NC, A> where N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &EntityUserLink) -> ManagementWebpropertyUserLinkInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &EntityUserLink) -> ManagementWebpropertyUserLinkInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -14792,7 +14788,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkInsertCall<'a, C, NC, A> where N /// we provide this method for API completeness. /// /// Account ID to create the user link for. - pub fn account_id(mut self, new_value: &str) -> ManagementWebpropertyUserLinkInsertCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementWebpropertyUserLinkInsertCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -14802,7 +14798,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkInsertCall<'a, C, NC, A> where N /// we provide this method for API completeness. /// /// Web Property ID to create the user link for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementWebpropertyUserLinkInsertCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementWebpropertyUserLinkInsertCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -14813,7 +14809,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkInsertCall<'a, C, NC, A> where N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebpropertyUserLinkInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebpropertyUserLinkInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14834,7 +14830,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkInsertCall<'a, C, NC, A> where N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementWebpropertyUserLinkInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementWebpropertyUserLinkInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14851,7 +14847,7 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkInsertCall<'a, C, NC, A> where N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementWebpropertyUserLinkInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementWebpropertyUserLinkInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14889,10 +14885,10 @@ impl<'a, C, NC, A> ManagementWebpropertyUserLinkInsertCall<'a, C, NC, A> where N /// .doit(); /// # } /// ``` -pub struct ManagementExperimentDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementExperimentDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _profile_id: String, @@ -14902,9 +14898,9 @@ pub struct ManagementExperimentDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementExperimentDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementExperimentDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementExperimentDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementExperimentDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15028,7 +15024,7 @@ impl<'a, C, NC, A> ManagementExperimentDeleteCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Account ID to which the experiment belongs - pub fn account_id(mut self, new_value: &str) -> ManagementExperimentDeleteCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementExperimentDeleteCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -15038,7 +15034,7 @@ impl<'a, C, NC, A> ManagementExperimentDeleteCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Web property ID to which the experiment belongs - pub fn web_property_id(mut self, new_value: &str) -> ManagementExperimentDeleteCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementExperimentDeleteCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -15048,7 +15044,7 @@ impl<'a, C, NC, A> ManagementExperimentDeleteCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// View (Profile) ID to which the experiment belongs - pub fn profile_id(mut self, new_value: &str) -> ManagementExperimentDeleteCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementExperimentDeleteCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -15058,7 +15054,7 @@ impl<'a, C, NC, A> ManagementExperimentDeleteCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// ID of the experiment to delete - pub fn experiment_id(mut self, new_value: &str) -> ManagementExperimentDeleteCall<'a, C, NC, A> { + pub fn experiment_id(mut self, new_value: &str) -> ManagementExperimentDeleteCall<'a, C, A> { self._experiment_id = new_value.to_string(); self } @@ -15069,7 +15065,7 @@ impl<'a, C, NC, A> ManagementExperimentDeleteCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementExperimentDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementExperimentDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15090,7 +15086,7 @@ impl<'a, C, NC, A> ManagementExperimentDeleteCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementExperimentDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementExperimentDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15107,7 +15103,7 @@ impl<'a, C, NC, A> ManagementExperimentDeleteCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementExperimentDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementExperimentDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15151,10 +15147,10 @@ impl<'a, C, NC, A> ManagementExperimentDeleteCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct ManagementProfilePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementProfilePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: Profile, _account_id: String, _web_property_id: String, @@ -15164,9 +15160,9 @@ pub struct ManagementProfilePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementProfilePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementProfilePatchCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementProfilePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementProfilePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15307,7 +15303,7 @@ impl<'a, C, NC, A> ManagementProfilePatchCall<'a, C, NC, A> where NC: hyper::net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Profile) -> ManagementProfilePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Profile) -> ManagementProfilePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -15317,7 +15313,7 @@ impl<'a, C, NC, A> ManagementProfilePatchCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Account ID to which the view (profile) belongs - pub fn account_id(mut self, new_value: &str) -> ManagementProfilePatchCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementProfilePatchCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -15327,7 +15323,7 @@ impl<'a, C, NC, A> ManagementProfilePatchCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Web property ID to which the view (profile) belongs - pub fn web_property_id(mut self, new_value: &str) -> ManagementProfilePatchCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementProfilePatchCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -15337,7 +15333,7 @@ impl<'a, C, NC, A> ManagementProfilePatchCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// ID of the view (profile) to be updated. - pub fn profile_id(mut self, new_value: &str) -> ManagementProfilePatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementProfilePatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -15348,7 +15344,7 @@ impl<'a, C, NC, A> ManagementProfilePatchCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfilePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfilePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15369,7 +15365,7 @@ impl<'a, C, NC, A> ManagementProfilePatchCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementProfilePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementProfilePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15386,7 +15382,7 @@ impl<'a, C, NC, A> ManagementProfilePatchCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementProfilePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementProfilePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15424,10 +15420,10 @@ impl<'a, C, NC, A> ManagementProfilePatchCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct ManagementFilterGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementFilterGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _filter_id: String, _delegate: Option<&'a mut Delegate>, @@ -15435,9 +15431,9 @@ pub struct ManagementFilterGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementFilterGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementFilterGetCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementFilterGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementFilterGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15570,7 +15566,7 @@ impl<'a, C, NC, A> ManagementFilterGetCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Account ID to retrieve filters for. - pub fn account_id(mut self, new_value: &str) -> ManagementFilterGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementFilterGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -15580,7 +15576,7 @@ impl<'a, C, NC, A> ManagementFilterGetCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Filter ID to retrieve filters for. - pub fn filter_id(mut self, new_value: &str) -> ManagementFilterGetCall<'a, C, NC, A> { + pub fn filter_id(mut self, new_value: &str) -> ManagementFilterGetCall<'a, C, A> { self._filter_id = new_value.to_string(); self } @@ -15591,7 +15587,7 @@ impl<'a, C, NC, A> ManagementFilterGetCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementFilterGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementFilterGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15612,7 +15608,7 @@ impl<'a, C, NC, A> ManagementFilterGetCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementFilterGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementFilterGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15629,7 +15625,7 @@ impl<'a, C, NC, A> ManagementFilterGetCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementFilterGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementFilterGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15669,10 +15665,10 @@ impl<'a, C, NC, A> ManagementFilterGetCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct ManagementWebPropertyAdWordsLinkListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementWebPropertyAdWordsLinkListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _start_index: Option, @@ -15682,9 +15678,9 @@ pub struct ManagementWebPropertyAdWordsLinkListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementWebPropertyAdWordsLinkListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementWebPropertyAdWordsLinkListCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementWebPropertyAdWordsLinkListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15823,7 +15819,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkListCall<'a, C, NC, A> where /// we provide this method for API completeness. /// /// ID of the account which the given web property belongs to. - pub fn account_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -15833,7 +15829,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkListCall<'a, C, NC, A> where /// we provide this method for API completeness. /// /// Web property ID to retrieve the AdWords links for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkListCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkListCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -15841,7 +15837,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkListCall<'a, C, NC, A> where /// /// /// An index of the first webProperty-AdWords link to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter. - pub fn start_index(mut self, new_value: i32) -> ManagementWebPropertyAdWordsLinkListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> ManagementWebPropertyAdWordsLinkListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -15849,7 +15845,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkListCall<'a, C, NC, A> where /// /// /// The maximum number of webProperty-AdWords links to include in this response. - pub fn max_results(mut self, new_value: i32) -> ManagementWebPropertyAdWordsLinkListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ManagementWebPropertyAdWordsLinkListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -15860,7 +15856,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkListCall<'a, C, NC, A> where /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebPropertyAdWordsLinkListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebPropertyAdWordsLinkListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15881,7 +15877,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkListCall<'a, C, NC, A> where /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementWebPropertyAdWordsLinkListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementWebPropertyAdWordsLinkListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15898,7 +15894,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkListCall<'a, C, NC, A> where /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementWebPropertyAdWordsLinkListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementWebPropertyAdWordsLinkListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15938,10 +15934,10 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkListCall<'a, C, NC, A> where /// .doit(); /// # } /// ``` -pub struct ManagementAccountSummaryListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementAccountSummaryListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _start_index: Option, _max_results: Option, _delegate: Option<&'a mut Delegate>, @@ -15949,9 +15945,9 @@ pub struct ManagementAccountSummaryListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementAccountSummaryListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementAccountSummaryListCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementAccountSummaryListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementAccountSummaryListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16062,7 +16058,7 @@ impl<'a, C, NC, A> ManagementAccountSummaryListCall<'a, C, NC, A> where NC: hype /// /// /// An index of the first entity to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter. - pub fn start_index(mut self, new_value: i32) -> ManagementAccountSummaryListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> ManagementAccountSummaryListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -16070,7 +16066,7 @@ impl<'a, C, NC, A> ManagementAccountSummaryListCall<'a, C, NC, A> where NC: hype /// /// /// The maximum number of account summaries to include in this response, where the largest acceptable value is 1000. - pub fn max_results(mut self, new_value: i32) -> ManagementAccountSummaryListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ManagementAccountSummaryListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -16081,7 +16077,7 @@ impl<'a, C, NC, A> ManagementAccountSummaryListCall<'a, C, NC, A> where NC: hype /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementAccountSummaryListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementAccountSummaryListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16102,7 +16098,7 @@ impl<'a, C, NC, A> ManagementAccountSummaryListCall<'a, C, NC, A> where NC: hype /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementAccountSummaryListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementAccountSummaryListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16119,7 +16115,7 @@ impl<'a, C, NC, A> ManagementAccountSummaryListCall<'a, C, NC, A> where NC: hype /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementAccountSummaryListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementAccountSummaryListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16159,10 +16155,10 @@ impl<'a, C, NC, A> ManagementAccountSummaryListCall<'a, C, NC, A> where NC: hype /// .doit(); /// # } /// ``` -pub struct ManagementCustomDimensionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementCustomDimensionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _start_index: Option, @@ -16172,9 +16168,9 @@ pub struct ManagementCustomDimensionListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementCustomDimensionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementCustomDimensionListCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementCustomDimensionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementCustomDimensionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16313,7 +16309,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionListCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// Account ID for the custom dimensions to retrieve. - pub fn account_id(mut self, new_value: &str) -> ManagementCustomDimensionListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementCustomDimensionListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -16323,7 +16319,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionListCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// Web property ID for the custom dimensions to retrieve. - pub fn web_property_id(mut self, new_value: &str) -> ManagementCustomDimensionListCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementCustomDimensionListCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -16331,7 +16327,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionListCall<'a, C, NC, A> where NC: hyp /// /// /// An index of the first entity to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter. - pub fn start_index(mut self, new_value: i32) -> ManagementCustomDimensionListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> ManagementCustomDimensionListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -16339,7 +16335,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionListCall<'a, C, NC, A> where NC: hyp /// /// /// The maximum number of custom dimensions to include in this response. - pub fn max_results(mut self, new_value: i32) -> ManagementCustomDimensionListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ManagementCustomDimensionListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -16350,7 +16346,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionListCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementCustomDimensionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementCustomDimensionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16371,7 +16367,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionListCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementCustomDimensionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementCustomDimensionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16388,7 +16384,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionListCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementCustomDimensionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementCustomDimensionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16428,10 +16424,10 @@ impl<'a, C, NC, A> ManagementCustomDimensionListCall<'a, C, NC, A> where NC: hyp /// .doit(); /// # } /// ``` -pub struct ManagementUploadListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementUploadListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _custom_data_source_id: String, @@ -16442,9 +16438,9 @@ pub struct ManagementUploadListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementUploadListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementUploadListCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementUploadListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementUploadListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16584,7 +16580,7 @@ impl<'a, C, NC, A> ManagementUploadListCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Account Id for the uploads to retrieve. - pub fn account_id(mut self, new_value: &str) -> ManagementUploadListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementUploadListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -16594,7 +16590,7 @@ impl<'a, C, NC, A> ManagementUploadListCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Web property Id for the uploads to retrieve. - pub fn web_property_id(mut self, new_value: &str) -> ManagementUploadListCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementUploadListCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -16604,7 +16600,7 @@ impl<'a, C, NC, A> ManagementUploadListCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Custom data source Id for uploads to retrieve. - pub fn custom_data_source_id(mut self, new_value: &str) -> ManagementUploadListCall<'a, C, NC, A> { + pub fn custom_data_source_id(mut self, new_value: &str) -> ManagementUploadListCall<'a, C, A> { self._custom_data_source_id = new_value.to_string(); self } @@ -16612,7 +16608,7 @@ impl<'a, C, NC, A> ManagementUploadListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// A 1-based index of the first upload to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter. - pub fn start_index(mut self, new_value: i32) -> ManagementUploadListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> ManagementUploadListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -16620,7 +16616,7 @@ impl<'a, C, NC, A> ManagementUploadListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// The maximum number of uploads to include in this response. - pub fn max_results(mut self, new_value: i32) -> ManagementUploadListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ManagementUploadListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -16631,7 +16627,7 @@ impl<'a, C, NC, A> ManagementUploadListCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementUploadListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementUploadListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16652,7 +16648,7 @@ impl<'a, C, NC, A> ManagementUploadListCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementUploadListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementUploadListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16669,7 +16665,7 @@ impl<'a, C, NC, A> ManagementUploadListCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementUploadListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementUploadListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16709,10 +16705,10 @@ impl<'a, C, NC, A> ManagementUploadListCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct ManagementProfileUserLinkListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementProfileUserLinkListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _profile_id: String, @@ -16723,9 +16719,9 @@ pub struct ManagementProfileUserLinkListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementProfileUserLinkListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementProfileUserLinkListCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementProfileUserLinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementProfileUserLinkListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16865,7 +16861,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkListCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// Account ID which the given view (profile) belongs to. - pub fn account_id(mut self, new_value: &str) -> ManagementProfileUserLinkListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementProfileUserLinkListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -16875,7 +16871,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkListCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// Web Property ID which the given view (profile) belongs to. Can either be a specific web property ID or '~all', which refers to all the web properties that user has access to. - pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileUserLinkListCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileUserLinkListCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -16885,7 +16881,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkListCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// View (Profile) ID to retrieve the profile-user links for. Can either be a specific profile ID or '~all', which refers to all the profiles that user has access to. - pub fn profile_id(mut self, new_value: &str) -> ManagementProfileUserLinkListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementProfileUserLinkListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -16893,7 +16889,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkListCall<'a, C, NC, A> where NC: hyp /// /// /// An index of the first profile-user link to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter. - pub fn start_index(mut self, new_value: i32) -> ManagementProfileUserLinkListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> ManagementProfileUserLinkListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -16901,7 +16897,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkListCall<'a, C, NC, A> where NC: hyp /// /// /// The maximum number of profile-user links to include in this response. - pub fn max_results(mut self, new_value: i32) -> ManagementProfileUserLinkListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ManagementProfileUserLinkListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -16912,7 +16908,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkListCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileUserLinkListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileUserLinkListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16933,7 +16929,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkListCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementProfileUserLinkListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementProfileUserLinkListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16950,7 +16946,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkListCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementProfileUserLinkListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementProfileUserLinkListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16990,10 +16986,10 @@ impl<'a, C, NC, A> ManagementProfileUserLinkListCall<'a, C, NC, A> where NC: hyp /// .doit(); /// # } /// ``` -pub struct ManagementAccountUserLinkListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementAccountUserLinkListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _start_index: Option, _max_results: Option, @@ -17002,9 +16998,9 @@ pub struct ManagementAccountUserLinkListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementAccountUserLinkListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementAccountUserLinkListCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementAccountUserLinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementAccountUserLinkListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17142,7 +17138,7 @@ impl<'a, C, NC, A> ManagementAccountUserLinkListCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// Account ID to retrieve the user links for. - pub fn account_id(mut self, new_value: &str) -> ManagementAccountUserLinkListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementAccountUserLinkListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -17150,7 +17146,7 @@ impl<'a, C, NC, A> ManagementAccountUserLinkListCall<'a, C, NC, A> where NC: hyp /// /// /// An index of the first account-user link to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter. - pub fn start_index(mut self, new_value: i32) -> ManagementAccountUserLinkListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> ManagementAccountUserLinkListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -17158,7 +17154,7 @@ impl<'a, C, NC, A> ManagementAccountUserLinkListCall<'a, C, NC, A> where NC: hyp /// /// /// The maximum number of account-user links to include in this response. - pub fn max_results(mut self, new_value: i32) -> ManagementAccountUserLinkListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ManagementAccountUserLinkListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -17169,7 +17165,7 @@ impl<'a, C, NC, A> ManagementAccountUserLinkListCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementAccountUserLinkListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementAccountUserLinkListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17190,7 +17186,7 @@ impl<'a, C, NC, A> ManagementAccountUserLinkListCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementAccountUserLinkListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementAccountUserLinkListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17207,7 +17203,7 @@ impl<'a, C, NC, A> ManagementAccountUserLinkListCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementAccountUserLinkListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementAccountUserLinkListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17252,10 +17248,10 @@ impl<'a, C, NC, A> ManagementAccountUserLinkListCall<'a, C, NC, A> where NC: hyp /// .doit(); /// # } /// ``` -pub struct ManagementCustomMetricUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementCustomMetricUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: CustomMetric, _account_id: String, _web_property_id: String, @@ -17266,9 +17262,9 @@ pub struct ManagementCustomMetricUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementCustomMetricUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementCustomMetricUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementCustomMetricUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementCustomMetricUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17412,7 +17408,7 @@ impl<'a, C, NC, A> ManagementCustomMetricUpdateCall<'a, C, NC, A> where NC: hype /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CustomMetric) -> ManagementCustomMetricUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CustomMetric) -> ManagementCustomMetricUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -17422,7 +17418,7 @@ impl<'a, C, NC, A> ManagementCustomMetricUpdateCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// Account ID for the custom metric to update. - pub fn account_id(mut self, new_value: &str) -> ManagementCustomMetricUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementCustomMetricUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -17432,7 +17428,7 @@ impl<'a, C, NC, A> ManagementCustomMetricUpdateCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// Web property ID for the custom metric to update. - pub fn web_property_id(mut self, new_value: &str) -> ManagementCustomMetricUpdateCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementCustomMetricUpdateCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -17442,7 +17438,7 @@ impl<'a, C, NC, A> ManagementCustomMetricUpdateCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// Custom metric ID for the custom metric to update. - pub fn custom_metric_id(mut self, new_value: &str) -> ManagementCustomMetricUpdateCall<'a, C, NC, A> { + pub fn custom_metric_id(mut self, new_value: &str) -> ManagementCustomMetricUpdateCall<'a, C, A> { self._custom_metric_id = new_value.to_string(); self } @@ -17450,7 +17446,7 @@ impl<'a, C, NC, A> ManagementCustomMetricUpdateCall<'a, C, NC, A> where NC: hype /// /// /// Force the update and ignore any warnings related to the custom metric being linked to a custom data source / data set. - pub fn ignore_custom_data_source_links(mut self, new_value: bool) -> ManagementCustomMetricUpdateCall<'a, C, NC, A> { + pub fn ignore_custom_data_source_links(mut self, new_value: bool) -> ManagementCustomMetricUpdateCall<'a, C, A> { self._ignore_custom_data_source_links = Some(new_value); self } @@ -17461,7 +17457,7 @@ impl<'a, C, NC, A> ManagementCustomMetricUpdateCall<'a, C, NC, A> where NC: hype /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementCustomMetricUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementCustomMetricUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17482,7 +17478,7 @@ impl<'a, C, NC, A> ManagementCustomMetricUpdateCall<'a, C, NC, A> where NC: hype /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementCustomMetricUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementCustomMetricUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17499,7 +17495,7 @@ impl<'a, C, NC, A> ManagementCustomMetricUpdateCall<'a, C, NC, A> where NC: hype /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementCustomMetricUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementCustomMetricUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17543,10 +17539,10 @@ impl<'a, C, NC, A> ManagementCustomMetricUpdateCall<'a, C, NC, A> where NC: hype /// .doit(); /// # } /// ``` -pub struct ManagementUploadDeleteUploadDataCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementUploadDeleteUploadDataCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: AnalyticsDataimportDeleteUploadDataRequest, _account_id: String, _web_property_id: String, @@ -17556,9 +17552,9 @@ pub struct ManagementUploadDeleteUploadDataCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementUploadDeleteUploadDataCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementUploadDeleteUploadDataCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementUploadDeleteUploadDataCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementUploadDeleteUploadDataCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17688,7 +17684,7 @@ impl<'a, C, NC, A> ManagementUploadDeleteUploadDataCall<'a, C, NC, A> where NC: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AnalyticsDataimportDeleteUploadDataRequest) -> ManagementUploadDeleteUploadDataCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AnalyticsDataimportDeleteUploadDataRequest) -> ManagementUploadDeleteUploadDataCall<'a, C, A> { self._request = new_value.clone(); self } @@ -17698,7 +17694,7 @@ impl<'a, C, NC, A> ManagementUploadDeleteUploadDataCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Account Id for the uploads to be deleted. - pub fn account_id(mut self, new_value: &str) -> ManagementUploadDeleteUploadDataCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementUploadDeleteUploadDataCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -17708,7 +17704,7 @@ impl<'a, C, NC, A> ManagementUploadDeleteUploadDataCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Web property Id for the uploads to be deleted. - pub fn web_property_id(mut self, new_value: &str) -> ManagementUploadDeleteUploadDataCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementUploadDeleteUploadDataCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -17718,7 +17714,7 @@ impl<'a, C, NC, A> ManagementUploadDeleteUploadDataCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Custom data source Id for the uploads to be deleted. - pub fn custom_data_source_id(mut self, new_value: &str) -> ManagementUploadDeleteUploadDataCall<'a, C, NC, A> { + pub fn custom_data_source_id(mut self, new_value: &str) -> ManagementUploadDeleteUploadDataCall<'a, C, A> { self._custom_data_source_id = new_value.to_string(); self } @@ -17729,7 +17725,7 @@ impl<'a, C, NC, A> ManagementUploadDeleteUploadDataCall<'a, C, NC, A> where NC: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementUploadDeleteUploadDataCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementUploadDeleteUploadDataCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17750,7 +17746,7 @@ impl<'a, C, NC, A> ManagementUploadDeleteUploadDataCall<'a, C, NC, A> where NC: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementUploadDeleteUploadDataCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementUploadDeleteUploadDataCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17767,7 +17763,7 @@ impl<'a, C, NC, A> ManagementUploadDeleteUploadDataCall<'a, C, NC, A> where NC: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementUploadDeleteUploadDataCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementUploadDeleteUploadDataCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17811,10 +17807,10 @@ impl<'a, C, NC, A> ManagementUploadDeleteUploadDataCall<'a, C, NC, A> where NC: /// .doit(); /// # } /// ``` -pub struct ManagementExperimentUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementExperimentUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: Experiment, _account_id: String, _web_property_id: String, @@ -17825,9 +17821,9 @@ pub struct ManagementExperimentUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementExperimentUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementExperimentUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementExperimentUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementExperimentUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17969,7 +17965,7 @@ impl<'a, C, NC, A> ManagementExperimentUpdateCall<'a, C, NC, A> where NC: hyper: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Experiment) -> ManagementExperimentUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Experiment) -> ManagementExperimentUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -17979,7 +17975,7 @@ impl<'a, C, NC, A> ManagementExperimentUpdateCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Account ID of the experiment to update. - pub fn account_id(mut self, new_value: &str) -> ManagementExperimentUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementExperimentUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -17989,7 +17985,7 @@ impl<'a, C, NC, A> ManagementExperimentUpdateCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Web property ID of the experiment to update. - pub fn web_property_id(mut self, new_value: &str) -> ManagementExperimentUpdateCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementExperimentUpdateCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -17999,7 +17995,7 @@ impl<'a, C, NC, A> ManagementExperimentUpdateCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// View (Profile) ID of the experiment to update. - pub fn profile_id(mut self, new_value: &str) -> ManagementExperimentUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementExperimentUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -18009,7 +18005,7 @@ impl<'a, C, NC, A> ManagementExperimentUpdateCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Experiment ID of the experiment to update. - pub fn experiment_id(mut self, new_value: &str) -> ManagementExperimentUpdateCall<'a, C, NC, A> { + pub fn experiment_id(mut self, new_value: &str) -> ManagementExperimentUpdateCall<'a, C, A> { self._experiment_id = new_value.to_string(); self } @@ -18020,7 +18016,7 @@ impl<'a, C, NC, A> ManagementExperimentUpdateCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementExperimentUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementExperimentUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18041,7 +18037,7 @@ impl<'a, C, NC, A> ManagementExperimentUpdateCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementExperimentUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementExperimentUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18058,7 +18054,7 @@ impl<'a, C, NC, A> ManagementExperimentUpdateCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementExperimentUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementExperimentUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18102,10 +18098,10 @@ impl<'a, C, NC, A> ManagementExperimentUpdateCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct ManagementGoalUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementGoalUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: Goal, _account_id: String, _web_property_id: String, @@ -18116,9 +18112,9 @@ pub struct ManagementGoalUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementGoalUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementGoalUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementGoalUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementGoalUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18260,7 +18256,7 @@ impl<'a, C, NC, A> ManagementGoalUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Goal) -> ManagementGoalUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Goal) -> ManagementGoalUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -18270,7 +18266,7 @@ impl<'a, C, NC, A> ManagementGoalUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Account ID to update the goal. - pub fn account_id(mut self, new_value: &str) -> ManagementGoalUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementGoalUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -18280,7 +18276,7 @@ impl<'a, C, NC, A> ManagementGoalUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Web property ID to update the goal. - pub fn web_property_id(mut self, new_value: &str) -> ManagementGoalUpdateCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementGoalUpdateCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -18290,7 +18286,7 @@ impl<'a, C, NC, A> ManagementGoalUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// View (Profile) ID to update the goal. - pub fn profile_id(mut self, new_value: &str) -> ManagementGoalUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementGoalUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -18300,7 +18296,7 @@ impl<'a, C, NC, A> ManagementGoalUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Index of the goal to be updated. - pub fn goal_id(mut self, new_value: &str) -> ManagementGoalUpdateCall<'a, C, NC, A> { + pub fn goal_id(mut self, new_value: &str) -> ManagementGoalUpdateCall<'a, C, A> { self._goal_id = new_value.to_string(); self } @@ -18311,7 +18307,7 @@ impl<'a, C, NC, A> ManagementGoalUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementGoalUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementGoalUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18332,7 +18328,7 @@ impl<'a, C, NC, A> ManagementGoalUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementGoalUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementGoalUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18349,7 +18345,7 @@ impl<'a, C, NC, A> ManagementGoalUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementGoalUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementGoalUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18389,10 +18385,10 @@ impl<'a, C, NC, A> ManagementGoalUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct ManagementCustomDataSourceListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementCustomDataSourceListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _start_index: Option, @@ -18402,9 +18398,9 @@ pub struct ManagementCustomDataSourceListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementCustomDataSourceListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementCustomDataSourceListCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementCustomDataSourceListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementCustomDataSourceListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18543,7 +18539,7 @@ impl<'a, C, NC, A> ManagementCustomDataSourceListCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// Account Id for the custom data sources to retrieve. - pub fn account_id(mut self, new_value: &str) -> ManagementCustomDataSourceListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementCustomDataSourceListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -18553,7 +18549,7 @@ impl<'a, C, NC, A> ManagementCustomDataSourceListCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// Web property Id for the custom data sources to retrieve. - pub fn web_property_id(mut self, new_value: &str) -> ManagementCustomDataSourceListCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementCustomDataSourceListCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -18561,7 +18557,7 @@ impl<'a, C, NC, A> ManagementCustomDataSourceListCall<'a, C, NC, A> where NC: hy /// /// /// A 1-based index of the first custom data source to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter. - pub fn start_index(mut self, new_value: i32) -> ManagementCustomDataSourceListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> ManagementCustomDataSourceListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -18569,7 +18565,7 @@ impl<'a, C, NC, A> ManagementCustomDataSourceListCall<'a, C, NC, A> where NC: hy /// /// /// The maximum number of custom data sources to include in this response. - pub fn max_results(mut self, new_value: i32) -> ManagementCustomDataSourceListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ManagementCustomDataSourceListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -18580,7 +18576,7 @@ impl<'a, C, NC, A> ManagementCustomDataSourceListCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementCustomDataSourceListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementCustomDataSourceListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18601,7 +18597,7 @@ impl<'a, C, NC, A> ManagementCustomDataSourceListCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementCustomDataSourceListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementCustomDataSourceListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18618,7 +18614,7 @@ impl<'a, C, NC, A> ManagementCustomDataSourceListCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementCustomDataSourceListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementCustomDataSourceListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18658,10 +18654,10 @@ impl<'a, C, NC, A> ManagementCustomDataSourceListCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct ManagementCustomMetricListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementCustomMetricListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _start_index: Option, @@ -18671,9 +18667,9 @@ pub struct ManagementCustomMetricListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementCustomMetricListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementCustomMetricListCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementCustomMetricListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementCustomMetricListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18812,7 +18808,7 @@ impl<'a, C, NC, A> ManagementCustomMetricListCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Account ID for the custom metrics to retrieve. - pub fn account_id(mut self, new_value: &str) -> ManagementCustomMetricListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementCustomMetricListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -18822,7 +18818,7 @@ impl<'a, C, NC, A> ManagementCustomMetricListCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Web property ID for the custom metrics to retrieve. - pub fn web_property_id(mut self, new_value: &str) -> ManagementCustomMetricListCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementCustomMetricListCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -18830,7 +18826,7 @@ impl<'a, C, NC, A> ManagementCustomMetricListCall<'a, C, NC, A> where NC: hyper: /// /// /// An index of the first entity to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter. - pub fn start_index(mut self, new_value: i32) -> ManagementCustomMetricListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> ManagementCustomMetricListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -18838,7 +18834,7 @@ impl<'a, C, NC, A> ManagementCustomMetricListCall<'a, C, NC, A> where NC: hyper: /// /// /// The maximum number of custom metrics to include in this response. - pub fn max_results(mut self, new_value: i32) -> ManagementCustomMetricListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ManagementCustomMetricListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -18849,7 +18845,7 @@ impl<'a, C, NC, A> ManagementCustomMetricListCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementCustomMetricListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementCustomMetricListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18870,7 +18866,7 @@ impl<'a, C, NC, A> ManagementCustomMetricListCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementCustomMetricListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementCustomMetricListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18887,7 +18883,7 @@ impl<'a, C, NC, A> ManagementCustomMetricListCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementCustomMetricListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementCustomMetricListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18927,10 +18923,10 @@ impl<'a, C, NC, A> ManagementCustomMetricListCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct ManagementUnsampledReportListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementUnsampledReportListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _profile_id: String, @@ -18941,9 +18937,9 @@ pub struct ManagementUnsampledReportListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementUnsampledReportListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementUnsampledReportListCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementUnsampledReportListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementUnsampledReportListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19083,7 +19079,7 @@ impl<'a, C, NC, A> ManagementUnsampledReportListCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// Account ID to retrieve unsampled reports for. Must be a specific account ID, ~all is not supported. - pub fn account_id(mut self, new_value: &str) -> ManagementUnsampledReportListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementUnsampledReportListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -19093,7 +19089,7 @@ impl<'a, C, NC, A> ManagementUnsampledReportListCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// Web property ID to retrieve unsampled reports for. Must be a specific web property ID, ~all is not supported. - pub fn web_property_id(mut self, new_value: &str) -> ManagementUnsampledReportListCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementUnsampledReportListCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -19103,7 +19099,7 @@ impl<'a, C, NC, A> ManagementUnsampledReportListCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// View (Profile) ID to retrieve unsampled reports for. Must be a specific view (profile) ID, ~all is not supported. - pub fn profile_id(mut self, new_value: &str) -> ManagementUnsampledReportListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementUnsampledReportListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -19111,7 +19107,7 @@ impl<'a, C, NC, A> ManagementUnsampledReportListCall<'a, C, NC, A> where NC: hyp /// /// /// An index of the first unsampled report to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter. - pub fn start_index(mut self, new_value: i32) -> ManagementUnsampledReportListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> ManagementUnsampledReportListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -19119,7 +19115,7 @@ impl<'a, C, NC, A> ManagementUnsampledReportListCall<'a, C, NC, A> where NC: hyp /// /// /// The maximum number of unsampled reports to include in this response. - pub fn max_results(mut self, new_value: i32) -> ManagementUnsampledReportListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ManagementUnsampledReportListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -19130,7 +19126,7 @@ impl<'a, C, NC, A> ManagementUnsampledReportListCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementUnsampledReportListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementUnsampledReportListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19151,7 +19147,7 @@ impl<'a, C, NC, A> ManagementUnsampledReportListCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementUnsampledReportListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementUnsampledReportListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19168,7 +19164,7 @@ impl<'a, C, NC, A> ManagementUnsampledReportListCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementUnsampledReportListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementUnsampledReportListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19206,10 +19202,10 @@ impl<'a, C, NC, A> ManagementUnsampledReportListCall<'a, C, NC, A> where NC: hyp /// .doit(); /// # } /// ``` -pub struct ManagementWebpropertyGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementWebpropertyGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _delegate: Option<&'a mut Delegate>, @@ -19217,9 +19213,9 @@ pub struct ManagementWebpropertyGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementWebpropertyGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementWebpropertyGetCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementWebpropertyGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementWebpropertyGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19352,7 +19348,7 @@ impl<'a, C, NC, A> ManagementWebpropertyGetCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Account ID to retrieve the web property for. - pub fn account_id(mut self, new_value: &str) -> ManagementWebpropertyGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementWebpropertyGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -19362,7 +19358,7 @@ impl<'a, C, NC, A> ManagementWebpropertyGetCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// ID to retrieve the web property for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementWebpropertyGetCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementWebpropertyGetCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -19373,7 +19369,7 @@ impl<'a, C, NC, A> ManagementWebpropertyGetCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebpropertyGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebpropertyGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19394,7 +19390,7 @@ impl<'a, C, NC, A> ManagementWebpropertyGetCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementWebpropertyGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementWebpropertyGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19411,7 +19407,7 @@ impl<'a, C, NC, A> ManagementWebpropertyGetCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementWebpropertyGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementWebpropertyGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19455,10 +19451,10 @@ impl<'a, C, NC, A> ManagementWebpropertyGetCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct ManagementExperimentInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementExperimentInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: Experiment, _account_id: String, _web_property_id: String, @@ -19468,9 +19464,9 @@ pub struct ManagementExperimentInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementExperimentInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementExperimentInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementExperimentInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementExperimentInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19611,7 +19607,7 @@ impl<'a, C, NC, A> ManagementExperimentInsertCall<'a, C, NC, A> where NC: hyper: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Experiment) -> ManagementExperimentInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Experiment) -> ManagementExperimentInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -19621,7 +19617,7 @@ impl<'a, C, NC, A> ManagementExperimentInsertCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Account ID to create the experiment for. - pub fn account_id(mut self, new_value: &str) -> ManagementExperimentInsertCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementExperimentInsertCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -19631,7 +19627,7 @@ impl<'a, C, NC, A> ManagementExperimentInsertCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Web property ID to create the experiment for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementExperimentInsertCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementExperimentInsertCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -19641,7 +19637,7 @@ impl<'a, C, NC, A> ManagementExperimentInsertCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// View (Profile) ID to create the experiment for. - pub fn profile_id(mut self, new_value: &str) -> ManagementExperimentInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementExperimentInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -19652,7 +19648,7 @@ impl<'a, C, NC, A> ManagementExperimentInsertCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementExperimentInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementExperimentInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19673,7 +19669,7 @@ impl<'a, C, NC, A> ManagementExperimentInsertCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementExperimentInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementExperimentInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19690,7 +19686,7 @@ impl<'a, C, NC, A> ManagementExperimentInsertCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementExperimentInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementExperimentInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19728,10 +19724,10 @@ impl<'a, C, NC, A> ManagementExperimentInsertCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct ManagementCustomDimensionGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementCustomDimensionGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _custom_dimension_id: String, @@ -19740,9 +19736,9 @@ pub struct ManagementCustomDimensionGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementCustomDimensionGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementCustomDimensionGetCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementCustomDimensionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementCustomDimensionGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19876,7 +19872,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionGetCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// Account ID for the custom dimension to retrieve. - pub fn account_id(mut self, new_value: &str) -> ManagementCustomDimensionGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementCustomDimensionGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -19886,7 +19882,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionGetCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// Web property ID for the custom dimension to retrieve. - pub fn web_property_id(mut self, new_value: &str) -> ManagementCustomDimensionGetCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementCustomDimensionGetCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -19896,7 +19892,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionGetCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// The ID of the custom dimension to retrieve. - pub fn custom_dimension_id(mut self, new_value: &str) -> ManagementCustomDimensionGetCall<'a, C, NC, A> { + pub fn custom_dimension_id(mut self, new_value: &str) -> ManagementCustomDimensionGetCall<'a, C, A> { self._custom_dimension_id = new_value.to_string(); self } @@ -19907,7 +19903,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionGetCall<'a, C, NC, A> where NC: hype /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementCustomDimensionGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementCustomDimensionGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19928,7 +19924,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionGetCall<'a, C, NC, A> where NC: hype /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementCustomDimensionGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementCustomDimensionGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19945,7 +19941,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionGetCall<'a, C, NC, A> where NC: hype /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementCustomDimensionGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementCustomDimensionGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19985,10 +19981,10 @@ impl<'a, C, NC, A> ManagementCustomDimensionGetCall<'a, C, NC, A> where NC: hype /// .doit(); /// # } /// ``` -pub struct ManagementProfileFilterLinkListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementProfileFilterLinkListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _profile_id: String, @@ -19999,9 +19995,9 @@ pub struct ManagementProfileFilterLinkListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementProfileFilterLinkListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementProfileFilterLinkListCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementProfileFilterLinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementProfileFilterLinkListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -20141,7 +20137,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkListCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Account ID to retrieve profile filter links for. - pub fn account_id(mut self, new_value: &str) -> ManagementProfileFilterLinkListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementProfileFilterLinkListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -20151,7 +20147,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkListCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Web property Id for profile filter links for. Can either be a specific web property ID or '~all', which refers to all the web properties that user has access to. - pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileFilterLinkListCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileFilterLinkListCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -20161,7 +20157,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkListCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Profile ID to retrieve filter links for. Can either be a specific profile ID or '~all', which refers to all the profiles that user has access to. - pub fn profile_id(mut self, new_value: &str) -> ManagementProfileFilterLinkListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementProfileFilterLinkListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -20169,7 +20165,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkListCall<'a, C, NC, A> where NC: h /// /// /// An index of the first entity to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter. - pub fn start_index(mut self, new_value: i32) -> ManagementProfileFilterLinkListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> ManagementProfileFilterLinkListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -20177,7 +20173,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkListCall<'a, C, NC, A> where NC: h /// /// /// The maximum number of profile filter links to include in this response. - pub fn max_results(mut self, new_value: i32) -> ManagementProfileFilterLinkListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ManagementProfileFilterLinkListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -20188,7 +20184,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkListCall<'a, C, NC, A> where NC: h /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileFilterLinkListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileFilterLinkListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -20209,7 +20205,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkListCall<'a, C, NC, A> where NC: h /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementProfileFilterLinkListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementProfileFilterLinkListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -20226,7 +20222,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkListCall<'a, C, NC, A> where NC: h /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementProfileFilterLinkListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementProfileFilterLinkListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -20270,10 +20266,10 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkListCall<'a, C, NC, A> where NC: h /// .doit(); /// # } /// ``` -pub struct ManagementWebpropertyPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementWebpropertyPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: Webproperty, _account_id: String, _web_property_id: String, @@ -20282,9 +20278,9 @@ pub struct ManagementWebpropertyPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementWebpropertyPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementWebpropertyPatchCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementWebpropertyPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementWebpropertyPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -20424,7 +20420,7 @@ impl<'a, C, NC, A> ManagementWebpropertyPatchCall<'a, C, NC, A> where NC: hyper: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Webproperty) -> ManagementWebpropertyPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Webproperty) -> ManagementWebpropertyPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -20434,7 +20430,7 @@ impl<'a, C, NC, A> ManagementWebpropertyPatchCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Account ID to which the web property belongs - pub fn account_id(mut self, new_value: &str) -> ManagementWebpropertyPatchCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementWebpropertyPatchCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -20444,7 +20440,7 @@ impl<'a, C, NC, A> ManagementWebpropertyPatchCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Web property ID - pub fn web_property_id(mut self, new_value: &str) -> ManagementWebpropertyPatchCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementWebpropertyPatchCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -20455,7 +20451,7 @@ impl<'a, C, NC, A> ManagementWebpropertyPatchCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebpropertyPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebpropertyPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -20476,7 +20472,7 @@ impl<'a, C, NC, A> ManagementWebpropertyPatchCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementWebpropertyPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementWebpropertyPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -20493,7 +20489,7 @@ impl<'a, C, NC, A> ManagementWebpropertyPatchCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementWebpropertyPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementWebpropertyPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -20537,10 +20533,10 @@ impl<'a, C, NC, A> ManagementWebpropertyPatchCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct ManagementCustomDimensionInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementCustomDimensionInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: CustomDimension, _account_id: String, _web_property_id: String, @@ -20549,9 +20545,9 @@ pub struct ManagementCustomDimensionInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementCustomDimensionInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementCustomDimensionInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementCustomDimensionInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementCustomDimensionInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -20691,7 +20687,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionInsertCall<'a, C, NC, A> where NC: h /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CustomDimension) -> ManagementCustomDimensionInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CustomDimension) -> ManagementCustomDimensionInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -20701,7 +20697,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionInsertCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Account ID for the custom dimension to create. - pub fn account_id(mut self, new_value: &str) -> ManagementCustomDimensionInsertCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementCustomDimensionInsertCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -20711,7 +20707,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionInsertCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Web property ID for the custom dimension to create. - pub fn web_property_id(mut self, new_value: &str) -> ManagementCustomDimensionInsertCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementCustomDimensionInsertCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -20722,7 +20718,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionInsertCall<'a, C, NC, A> where NC: h /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementCustomDimensionInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementCustomDimensionInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -20743,7 +20739,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionInsertCall<'a, C, NC, A> where NC: h /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementCustomDimensionInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementCustomDimensionInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -20760,7 +20756,7 @@ impl<'a, C, NC, A> ManagementCustomDimensionInsertCall<'a, C, NC, A> where NC: h /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementCustomDimensionInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementCustomDimensionInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -20804,10 +20800,10 @@ impl<'a, C, NC, A> ManagementCustomDimensionInsertCall<'a, C, NC, A> where NC: h /// .doit(); /// # } /// ``` -pub struct ManagementCustomMetricInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementCustomMetricInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: CustomMetric, _account_id: String, _web_property_id: String, @@ -20816,9 +20812,9 @@ pub struct ManagementCustomMetricInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementCustomMetricInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementCustomMetricInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementCustomMetricInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementCustomMetricInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -20958,7 +20954,7 @@ impl<'a, C, NC, A> ManagementCustomMetricInsertCall<'a, C, NC, A> where NC: hype /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CustomMetric) -> ManagementCustomMetricInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CustomMetric) -> ManagementCustomMetricInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -20968,7 +20964,7 @@ impl<'a, C, NC, A> ManagementCustomMetricInsertCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// Account ID for the custom metric to create. - pub fn account_id(mut self, new_value: &str) -> ManagementCustomMetricInsertCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementCustomMetricInsertCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -20978,7 +20974,7 @@ impl<'a, C, NC, A> ManagementCustomMetricInsertCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// Web property ID for the custom dimension to create. - pub fn web_property_id(mut self, new_value: &str) -> ManagementCustomMetricInsertCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementCustomMetricInsertCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -20989,7 +20985,7 @@ impl<'a, C, NC, A> ManagementCustomMetricInsertCall<'a, C, NC, A> where NC: hype /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementCustomMetricInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementCustomMetricInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -21010,7 +21006,7 @@ impl<'a, C, NC, A> ManagementCustomMetricInsertCall<'a, C, NC, A> where NC: hype /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementCustomMetricInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementCustomMetricInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -21027,7 +21023,7 @@ impl<'a, C, NC, A> ManagementCustomMetricInsertCall<'a, C, NC, A> where NC: hype /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementCustomMetricInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementCustomMetricInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -21071,10 +21067,10 @@ impl<'a, C, NC, A> ManagementCustomMetricInsertCall<'a, C, NC, A> where NC: hype /// .doit(); /// # } /// ``` -pub struct ManagementProfileUserLinkInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementProfileUserLinkInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: EntityUserLink, _account_id: String, _web_property_id: String, @@ -21084,9 +21080,9 @@ pub struct ManagementProfileUserLinkInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementProfileUserLinkInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementProfileUserLinkInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementProfileUserLinkInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementProfileUserLinkInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -21227,7 +21223,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkInsertCall<'a, C, NC, A> where NC: h /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &EntityUserLink) -> ManagementProfileUserLinkInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &EntityUserLink) -> ManagementProfileUserLinkInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -21237,7 +21233,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkInsertCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Account ID to create the user link for. - pub fn account_id(mut self, new_value: &str) -> ManagementProfileUserLinkInsertCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementProfileUserLinkInsertCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -21247,7 +21243,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkInsertCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Web Property ID to create the user link for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileUserLinkInsertCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileUserLinkInsertCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -21257,7 +21253,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkInsertCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// View (Profile) ID to create the user link for. - pub fn profile_id(mut self, new_value: &str) -> ManagementProfileUserLinkInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementProfileUserLinkInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -21268,7 +21264,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkInsertCall<'a, C, NC, A> where NC: h /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileUserLinkInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileUserLinkInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -21289,7 +21285,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkInsertCall<'a, C, NC, A> where NC: h /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementProfileUserLinkInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementProfileUserLinkInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -21306,7 +21302,7 @@ impl<'a, C, NC, A> ManagementProfileUserLinkInsertCall<'a, C, NC, A> where NC: h /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementProfileUserLinkInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementProfileUserLinkInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -21346,10 +21342,10 @@ impl<'a, C, NC, A> ManagementProfileUserLinkInsertCall<'a, C, NC, A> where NC: h /// .doit(); /// # } /// ``` -pub struct ManagementWebpropertyListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementWebpropertyListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _start_index: Option, _max_results: Option, @@ -21358,9 +21354,9 @@ pub struct ManagementWebpropertyListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementWebpropertyListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementWebpropertyListCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementWebpropertyListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementWebpropertyListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -21498,7 +21494,7 @@ impl<'a, C, NC, A> ManagementWebpropertyListCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Account ID to retrieve web properties for. Can either be a specific account ID or '~all', which refers to all the accounts that user has access to. - pub fn account_id(mut self, new_value: &str) -> ManagementWebpropertyListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementWebpropertyListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -21506,7 +21502,7 @@ impl<'a, C, NC, A> ManagementWebpropertyListCall<'a, C, NC, A> where NC: hyper:: /// /// /// An index of the first entity to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter. - pub fn start_index(mut self, new_value: i32) -> ManagementWebpropertyListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> ManagementWebpropertyListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -21514,7 +21510,7 @@ impl<'a, C, NC, A> ManagementWebpropertyListCall<'a, C, NC, A> where NC: hyper:: /// /// /// The maximum number of web properties to include in this response. - pub fn max_results(mut self, new_value: i32) -> ManagementWebpropertyListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ManagementWebpropertyListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -21525,7 +21521,7 @@ impl<'a, C, NC, A> ManagementWebpropertyListCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebpropertyListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebpropertyListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -21546,7 +21542,7 @@ impl<'a, C, NC, A> ManagementWebpropertyListCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementWebpropertyListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementWebpropertyListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -21563,7 +21559,7 @@ impl<'a, C, NC, A> ManagementWebpropertyListCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementWebpropertyListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementWebpropertyListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -21607,10 +21603,10 @@ impl<'a, C, NC, A> ManagementWebpropertyListCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct ManagementWebPropertyAdWordsLinkInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementWebPropertyAdWordsLinkInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: EntityAdWordsLink, _account_id: String, _web_property_id: String, @@ -21619,9 +21615,9 @@ pub struct ManagementWebPropertyAdWordsLinkInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementWebPropertyAdWordsLinkInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementWebPropertyAdWordsLinkInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementWebPropertyAdWordsLinkInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -21761,7 +21757,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkInsertCall<'a, C, NC, A> wher /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &EntityAdWordsLink) -> ManagementWebPropertyAdWordsLinkInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &EntityAdWordsLink) -> ManagementWebPropertyAdWordsLinkInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -21771,7 +21767,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkInsertCall<'a, C, NC, A> wher /// we provide this method for API completeness. /// /// ID of the Google Analytics account to create the link for. - pub fn account_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkInsertCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkInsertCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -21781,7 +21777,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkInsertCall<'a, C, NC, A> wher /// we provide this method for API completeness. /// /// Web property ID to create the link for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkInsertCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkInsertCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -21792,7 +21788,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkInsertCall<'a, C, NC, A> wher /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebPropertyAdWordsLinkInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebPropertyAdWordsLinkInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -21813,7 +21809,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkInsertCall<'a, C, NC, A> wher /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementWebPropertyAdWordsLinkInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementWebPropertyAdWordsLinkInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -21830,7 +21826,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkInsertCall<'a, C, NC, A> wher /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementWebPropertyAdWordsLinkInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementWebPropertyAdWordsLinkInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -21874,10 +21870,10 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkInsertCall<'a, C, NC, A> wher /// .doit(); /// # } /// ``` -pub struct ManagementWebPropertyAdWordsLinkPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementWebPropertyAdWordsLinkPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: EntityAdWordsLink, _account_id: String, _web_property_id: String, @@ -21887,9 +21883,9 @@ pub struct ManagementWebPropertyAdWordsLinkPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementWebPropertyAdWordsLinkPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementWebPropertyAdWordsLinkPatchCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -22030,7 +22026,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, NC, A> where /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &EntityAdWordsLink) -> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &EntityAdWordsLink) -> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -22040,7 +22036,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, NC, A> where /// we provide this method for API completeness. /// /// ID of the account which the given web property belongs to. - pub fn account_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -22050,7 +22046,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, NC, A> where /// we provide this method for API completeness. /// /// Web property ID to retrieve the AdWords link for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -22060,7 +22056,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, NC, A> where /// we provide this method for API completeness. /// /// Web property-AdWords link ID. - pub fn web_property_ad_words_link_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, NC, A> { + pub fn web_property_ad_words_link_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, A> { self._web_property_ad_words_link_id = new_value.to_string(); self } @@ -22071,7 +22067,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, NC, A> where /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -22092,7 +22088,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, NC, A> where /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -22109,7 +22105,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, NC, A> where /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -22147,10 +22143,10 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkPatchCall<'a, C, NC, A> where /// .doit(); /// # } /// ``` -pub struct ManagementGoalGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementGoalGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _profile_id: String, @@ -22160,9 +22156,9 @@ pub struct ManagementGoalGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementGoalGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementGoalGetCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementGoalGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementGoalGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -22297,7 +22293,7 @@ impl<'a, C, NC, A> ManagementGoalGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Account ID to retrieve the goal for. - pub fn account_id(mut self, new_value: &str) -> ManagementGoalGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementGoalGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -22307,7 +22303,7 @@ impl<'a, C, NC, A> ManagementGoalGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Web property ID to retrieve the goal for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementGoalGetCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementGoalGetCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -22317,7 +22313,7 @@ impl<'a, C, NC, A> ManagementGoalGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// View (Profile) ID to retrieve the goal for. - pub fn profile_id(mut self, new_value: &str) -> ManagementGoalGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementGoalGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -22327,7 +22323,7 @@ impl<'a, C, NC, A> ManagementGoalGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Goal ID to retrieve the goal for. - pub fn goal_id(mut self, new_value: &str) -> ManagementGoalGetCall<'a, C, NC, A> { + pub fn goal_id(mut self, new_value: &str) -> ManagementGoalGetCall<'a, C, A> { self._goal_id = new_value.to_string(); self } @@ -22338,7 +22334,7 @@ impl<'a, C, NC, A> ManagementGoalGetCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementGoalGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementGoalGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -22359,7 +22355,7 @@ impl<'a, C, NC, A> ManagementGoalGetCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementGoalGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementGoalGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -22376,7 +22372,7 @@ impl<'a, C, NC, A> ManagementGoalGetCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementGoalGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementGoalGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -22414,10 +22410,10 @@ impl<'a, C, NC, A> ManagementGoalGetCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _web_property_ad_words_link_id: String, @@ -22426,9 +22422,9 @@ pub struct ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -22551,7 +22547,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, NC, A> wher /// we provide this method for API completeness. /// /// ID of the account which the given web property belongs to. - pub fn account_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -22561,7 +22557,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, NC, A> wher /// we provide this method for API completeness. /// /// Web property ID to delete the AdWords link for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -22571,7 +22567,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, NC, A> wher /// we provide this method for API completeness. /// /// Web property AdWords link ID. - pub fn web_property_ad_words_link_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, NC, A> { + pub fn web_property_ad_words_link_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, A> { self._web_property_ad_words_link_id = new_value.to_string(); self } @@ -22582,7 +22578,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, NC, A> wher /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -22603,7 +22599,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, NC, A> wher /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -22620,7 +22616,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, NC, A> wher /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -22664,10 +22660,10 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkDeleteCall<'a, C, NC, A> wher /// .doit(); /// # } /// ``` -pub struct ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: EntityAdWordsLink, _account_id: String, _web_property_id: String, @@ -22677,9 +22673,9 @@ pub struct ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -22820,7 +22816,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, NC, A> wher /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &EntityAdWordsLink) -> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &EntityAdWordsLink) -> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -22830,7 +22826,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, NC, A> wher /// we provide this method for API completeness. /// /// ID of the account which the given web property belongs to. - pub fn account_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -22840,7 +22836,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, NC, A> wher /// we provide this method for API completeness. /// /// Web property ID to retrieve the AdWords link for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -22850,7 +22846,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, NC, A> wher /// we provide this method for API completeness. /// /// Web property-AdWords link ID. - pub fn web_property_ad_words_link_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, NC, A> { + pub fn web_property_ad_words_link_id(mut self, new_value: &str) -> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, A> { self._web_property_ad_words_link_id = new_value.to_string(); self } @@ -22861,7 +22857,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, NC, A> wher /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -22882,7 +22878,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, NC, A> wher /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -22899,7 +22895,7 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, NC, A> wher /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -22943,10 +22939,10 @@ impl<'a, C, NC, A> ManagementWebPropertyAdWordsLinkUpdateCall<'a, C, NC, A> wher /// .doit(); /// # } /// ``` -pub struct ManagementFilterPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementFilterPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: Filter, _account_id: String, _filter_id: String, @@ -22955,9 +22951,9 @@ pub struct ManagementFilterPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementFilterPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementFilterPatchCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementFilterPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementFilterPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -23097,7 +23093,7 @@ impl<'a, C, NC, A> ManagementFilterPatchCall<'a, C, NC, A> where NC: hyper::net: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Filter) -> ManagementFilterPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Filter) -> ManagementFilterPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -23107,7 +23103,7 @@ impl<'a, C, NC, A> ManagementFilterPatchCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Account ID to which the filter belongs. - pub fn account_id(mut self, new_value: &str) -> ManagementFilterPatchCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementFilterPatchCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -23117,7 +23113,7 @@ impl<'a, C, NC, A> ManagementFilterPatchCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// ID of the filter to be updated. - pub fn filter_id(mut self, new_value: &str) -> ManagementFilterPatchCall<'a, C, NC, A> { + pub fn filter_id(mut self, new_value: &str) -> ManagementFilterPatchCall<'a, C, A> { self._filter_id = new_value.to_string(); self } @@ -23128,7 +23124,7 @@ impl<'a, C, NC, A> ManagementFilterPatchCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementFilterPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementFilterPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -23149,7 +23145,7 @@ impl<'a, C, NC, A> ManagementFilterPatchCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementFilterPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementFilterPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -23166,7 +23162,7 @@ impl<'a, C, NC, A> ManagementFilterPatchCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementFilterPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementFilterPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -23206,10 +23202,10 @@ impl<'a, C, NC, A> ManagementFilterPatchCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct ManagementFilterListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementFilterListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _start_index: Option, _max_results: Option, @@ -23218,9 +23214,9 @@ pub struct ManagementFilterListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementFilterListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementFilterListCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementFilterListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementFilterListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -23358,7 +23354,7 @@ impl<'a, C, NC, A> ManagementFilterListCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Account ID to retrieve filters for. - pub fn account_id(mut self, new_value: &str) -> ManagementFilterListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementFilterListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -23366,7 +23362,7 @@ impl<'a, C, NC, A> ManagementFilterListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// An index of the first entity to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter. - pub fn start_index(mut self, new_value: i32) -> ManagementFilterListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> ManagementFilterListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -23374,7 +23370,7 @@ impl<'a, C, NC, A> ManagementFilterListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// The maximum number of filters to include in this response. - pub fn max_results(mut self, new_value: i32) -> ManagementFilterListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ManagementFilterListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -23385,7 +23381,7 @@ impl<'a, C, NC, A> ManagementFilterListCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementFilterListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementFilterListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -23406,7 +23402,7 @@ impl<'a, C, NC, A> ManagementFilterListCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementFilterListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementFilterListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -23423,7 +23419,7 @@ impl<'a, C, NC, A> ManagementFilterListCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementFilterListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementFilterListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -23461,10 +23457,10 @@ impl<'a, C, NC, A> ManagementFilterListCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct ManagementFilterDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementFilterDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _filter_id: String, _delegate: Option<&'a mut Delegate>, @@ -23472,9 +23468,9 @@ pub struct ManagementFilterDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementFilterDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementFilterDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementFilterDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementFilterDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -23607,7 +23603,7 @@ impl<'a, C, NC, A> ManagementFilterDeleteCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Account ID to delete the filter for. - pub fn account_id(mut self, new_value: &str) -> ManagementFilterDeleteCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementFilterDeleteCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -23617,7 +23613,7 @@ impl<'a, C, NC, A> ManagementFilterDeleteCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// ID of the filter to be deleted. - pub fn filter_id(mut self, new_value: &str) -> ManagementFilterDeleteCall<'a, C, NC, A> { + pub fn filter_id(mut self, new_value: &str) -> ManagementFilterDeleteCall<'a, C, A> { self._filter_id = new_value.to_string(); self } @@ -23628,7 +23624,7 @@ impl<'a, C, NC, A> ManagementFilterDeleteCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementFilterDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementFilterDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -23649,7 +23645,7 @@ impl<'a, C, NC, A> ManagementFilterDeleteCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementFilterDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementFilterDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -23666,7 +23662,7 @@ impl<'a, C, NC, A> ManagementFilterDeleteCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementFilterDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementFilterDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -23710,10 +23706,10 @@ impl<'a, C, NC, A> ManagementFilterDeleteCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct ManagementProfileInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementProfileInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: Profile, _account_id: String, _web_property_id: String, @@ -23722,9 +23718,9 @@ pub struct ManagementProfileInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementProfileInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementProfileInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementProfileInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementProfileInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -23864,7 +23860,7 @@ impl<'a, C, NC, A> ManagementProfileInsertCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Profile) -> ManagementProfileInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Profile) -> ManagementProfileInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -23874,7 +23870,7 @@ impl<'a, C, NC, A> ManagementProfileInsertCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Account ID to create the view (profile) for. - pub fn account_id(mut self, new_value: &str) -> ManagementProfileInsertCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementProfileInsertCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -23884,7 +23880,7 @@ impl<'a, C, NC, A> ManagementProfileInsertCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Web property ID to create the view (profile) for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileInsertCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileInsertCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -23895,7 +23891,7 @@ impl<'a, C, NC, A> ManagementProfileInsertCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -23916,7 +23912,7 @@ impl<'a, C, NC, A> ManagementProfileInsertCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementProfileInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementProfileInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -23933,7 +23929,7 @@ impl<'a, C, NC, A> ManagementProfileInsertCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementProfileInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementProfileInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -23971,10 +23967,10 @@ impl<'a, C, NC, A> ManagementProfileInsertCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct ManagementAccountUserLinkDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementAccountUserLinkDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _link_id: String, _delegate: Option<&'a mut Delegate>, @@ -23982,9 +23978,9 @@ pub struct ManagementAccountUserLinkDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementAccountUserLinkDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementAccountUserLinkDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementAccountUserLinkDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementAccountUserLinkDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -24106,7 +24102,7 @@ impl<'a, C, NC, A> ManagementAccountUserLinkDeleteCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Account ID to delete the user link for. - pub fn account_id(mut self, new_value: &str) -> ManagementAccountUserLinkDeleteCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementAccountUserLinkDeleteCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -24116,7 +24112,7 @@ impl<'a, C, NC, A> ManagementAccountUserLinkDeleteCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Link ID to delete the user link for. - pub fn link_id(mut self, new_value: &str) -> ManagementAccountUserLinkDeleteCall<'a, C, NC, A> { + pub fn link_id(mut self, new_value: &str) -> ManagementAccountUserLinkDeleteCall<'a, C, A> { self._link_id = new_value.to_string(); self } @@ -24127,7 +24123,7 @@ impl<'a, C, NC, A> ManagementAccountUserLinkDeleteCall<'a, C, NC, A> where NC: h /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementAccountUserLinkDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementAccountUserLinkDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -24148,7 +24144,7 @@ impl<'a, C, NC, A> ManagementAccountUserLinkDeleteCall<'a, C, NC, A> where NC: h /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementAccountUserLinkDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementAccountUserLinkDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -24165,7 +24161,7 @@ impl<'a, C, NC, A> ManagementAccountUserLinkDeleteCall<'a, C, NC, A> where NC: h /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementAccountUserLinkDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementAccountUserLinkDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -24209,10 +24205,10 @@ impl<'a, C, NC, A> ManagementAccountUserLinkDeleteCall<'a, C, NC, A> where NC: h /// .doit(); /// # } /// ``` -pub struct ManagementProfileUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementProfileUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: Profile, _account_id: String, _web_property_id: String, @@ -24222,9 +24218,9 @@ pub struct ManagementProfileUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementProfileUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementProfileUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementProfileUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementProfileUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -24365,7 +24361,7 @@ impl<'a, C, NC, A> ManagementProfileUpdateCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Profile) -> ManagementProfileUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Profile) -> ManagementProfileUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -24375,7 +24371,7 @@ impl<'a, C, NC, A> ManagementProfileUpdateCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Account ID to which the view (profile) belongs - pub fn account_id(mut self, new_value: &str) -> ManagementProfileUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementProfileUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -24385,7 +24381,7 @@ impl<'a, C, NC, A> ManagementProfileUpdateCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Web property ID to which the view (profile) belongs - pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileUpdateCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileUpdateCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -24395,7 +24391,7 @@ impl<'a, C, NC, A> ManagementProfileUpdateCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// ID of the view (profile) to be updated. - pub fn profile_id(mut self, new_value: &str) -> ManagementProfileUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementProfileUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -24406,7 +24402,7 @@ impl<'a, C, NC, A> ManagementProfileUpdateCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -24427,7 +24423,7 @@ impl<'a, C, NC, A> ManagementProfileUpdateCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementProfileUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementProfileUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -24444,7 +24440,7 @@ impl<'a, C, NC, A> ManagementProfileUpdateCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementProfileUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementProfileUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -24482,10 +24478,10 @@ impl<'a, C, NC, A> ManagementProfileUpdateCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct ManagementProfileFilterLinkGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagementProfileFilterLinkGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _account_id: String, _web_property_id: String, _profile_id: String, @@ -24495,9 +24491,9 @@ pub struct ManagementProfileFilterLinkGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagementProfileFilterLinkGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagementProfileFilterLinkGetCall<'a, C, A> {} -impl<'a, C, NC, A> ManagementProfileFilterLinkGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagementProfileFilterLinkGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -24632,7 +24628,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkGetCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// Account ID to retrieve profile filter link for. - pub fn account_id(mut self, new_value: &str) -> ManagementProfileFilterLinkGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> ManagementProfileFilterLinkGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -24642,7 +24638,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkGetCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// Web property Id to retrieve profile filter link for. - pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileFilterLinkGetCall<'a, C, NC, A> { + pub fn web_property_id(mut self, new_value: &str) -> ManagementProfileFilterLinkGetCall<'a, C, A> { self._web_property_id = new_value.to_string(); self } @@ -24652,7 +24648,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkGetCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// Profile ID to retrieve filter link for. - pub fn profile_id(mut self, new_value: &str) -> ManagementProfileFilterLinkGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ManagementProfileFilterLinkGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -24662,7 +24658,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkGetCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// ID of the profile filter link. - pub fn link_id(mut self, new_value: &str) -> ManagementProfileFilterLinkGetCall<'a, C, NC, A> { + pub fn link_id(mut self, new_value: &str) -> ManagementProfileFilterLinkGetCall<'a, C, A> { self._link_id = new_value.to_string(); self } @@ -24673,7 +24669,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkGetCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileFilterLinkGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagementProfileFilterLinkGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -24694,7 +24690,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkGetCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagementProfileFilterLinkGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagementProfileFilterLinkGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -24711,7 +24707,7 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkGetCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagementProfileFilterLinkGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagementProfileFilterLinkGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -24755,10 +24751,10 @@ impl<'a, C, NC, A> ManagementProfileFilterLinkGetCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct DataMcfGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DataMcfGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _ids: String, _start_date: String, _end_date: String, @@ -24774,9 +24770,9 @@ pub struct DataMcfGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DataMcfGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DataMcfGetCall<'a, C, A> {} -impl<'a, C, NC, A> DataMcfGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DataMcfGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -24905,7 +24901,7 @@ impl<'a, C, NC, A> DataMcfGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Unique table ID for retrieving Analytics data. Table ID is of the form ga:XXXX, where XXXX is the Analytics view (profile) ID. - pub fn ids(mut self, new_value: &str) -> DataMcfGetCall<'a, C, NC, A> { + pub fn ids(mut self, new_value: &str) -> DataMcfGetCall<'a, C, A> { self._ids = new_value.to_string(); self } @@ -24915,7 +24911,7 @@ impl<'a, C, NC, A> DataMcfGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Start date for fetching Analytics data. Requests can specify a start date formatted as YYYY-MM-DD, or as a relative date (e.g., today, yesterday, or 7daysAgo). The default value is 7daysAgo. - pub fn start_date(mut self, new_value: &str) -> DataMcfGetCall<'a, C, NC, A> { + pub fn start_date(mut self, new_value: &str) -> DataMcfGetCall<'a, C, A> { self._start_date = new_value.to_string(); self } @@ -24925,7 +24921,7 @@ impl<'a, C, NC, A> DataMcfGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// End date for fetching Analytics data. Requests can specify a start date formatted as YYYY-MM-DD, or as a relative date (e.g., today, yesterday, or 7daysAgo). The default value is 7daysAgo. - pub fn end_date(mut self, new_value: &str) -> DataMcfGetCall<'a, C, NC, A> { + pub fn end_date(mut self, new_value: &str) -> DataMcfGetCall<'a, C, A> { self._end_date = new_value.to_string(); self } @@ -24935,7 +24931,7 @@ impl<'a, C, NC, A> DataMcfGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// A comma-separated list of Multi-Channel Funnels metrics. E.g., 'mcf:totalConversions,mcf:totalConversionValue'. At least one metric must be specified. - pub fn metrics(mut self, new_value: &str) -> DataMcfGetCall<'a, C, NC, A> { + pub fn metrics(mut self, new_value: &str) -> DataMcfGetCall<'a, C, A> { self._metrics = new_value.to_string(); self } @@ -24943,7 +24939,7 @@ impl<'a, C, NC, A> DataMcfGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// An index of the first entity to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter. - pub fn start_index(mut self, new_value: i32) -> DataMcfGetCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> DataMcfGetCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -24951,7 +24947,7 @@ impl<'a, C, NC, A> DataMcfGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// A comma-separated list of dimensions or metrics that determine the sort order for the Analytics data. - pub fn sort(mut self, new_value: &str) -> DataMcfGetCall<'a, C, NC, A> { + pub fn sort(mut self, new_value: &str) -> DataMcfGetCall<'a, C, A> { self._sort = Some(new_value.to_string()); self } @@ -24959,7 +24955,7 @@ impl<'a, C, NC, A> DataMcfGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The desired sampling level. - pub fn sampling_level(mut self, new_value: &str) -> DataMcfGetCall<'a, C, NC, A> { + pub fn sampling_level(mut self, new_value: &str) -> DataMcfGetCall<'a, C, A> { self._sampling_level = Some(new_value.to_string()); self } @@ -24967,7 +24963,7 @@ impl<'a, C, NC, A> DataMcfGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The maximum number of entries to include in this feed. - pub fn max_results(mut self, new_value: i32) -> DataMcfGetCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> DataMcfGetCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -24975,7 +24971,7 @@ impl<'a, C, NC, A> DataMcfGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// A comma-separated list of dimension or metric filters to be applied to the Analytics data. - pub fn filters(mut self, new_value: &str) -> DataMcfGetCall<'a, C, NC, A> { + pub fn filters(mut self, new_value: &str) -> DataMcfGetCall<'a, C, A> { self._filters = Some(new_value.to_string()); self } @@ -24983,7 +24979,7 @@ impl<'a, C, NC, A> DataMcfGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// A comma-separated list of Multi-Channel Funnels dimensions. E.g., 'mcf:source,mcf:medium'. - pub fn dimensions(mut self, new_value: &str) -> DataMcfGetCall<'a, C, NC, A> { + pub fn dimensions(mut self, new_value: &str) -> DataMcfGetCall<'a, C, A> { self._dimensions = Some(new_value.to_string()); self } @@ -24994,7 +24990,7 @@ impl<'a, C, NC, A> DataMcfGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DataMcfGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DataMcfGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -25015,7 +25011,7 @@ impl<'a, C, NC, A> DataMcfGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DataMcfGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DataMcfGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -25032,7 +25028,7 @@ impl<'a, C, NC, A> DataMcfGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DataMcfGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DataMcfGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -25078,10 +25074,10 @@ impl<'a, C, NC, A> DataMcfGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct DataGaGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DataGaGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _ids: String, _start_date: String, _end_date: String, @@ -25099,9 +25095,9 @@ pub struct DataGaGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DataGaGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DataGaGetCall<'a, C, A> {} -impl<'a, C, NC, A> DataGaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DataGaGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -25236,7 +25232,7 @@ impl<'a, C, NC, A> DataGaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Unique table ID for retrieving Analytics data. Table ID is of the form ga:XXXX, where XXXX is the Analytics view (profile) ID. - pub fn ids(mut self, new_value: &str) -> DataGaGetCall<'a, C, NC, A> { + pub fn ids(mut self, new_value: &str) -> DataGaGetCall<'a, C, A> { self._ids = new_value.to_string(); self } @@ -25246,7 +25242,7 @@ impl<'a, C, NC, A> DataGaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Start date for fetching Analytics data. Requests can specify a start date formatted as YYYY-MM-DD, or as a relative date (e.g., today, yesterday, or 7daysAgo). The default value is 7daysAgo. - pub fn start_date(mut self, new_value: &str) -> DataGaGetCall<'a, C, NC, A> { + pub fn start_date(mut self, new_value: &str) -> DataGaGetCall<'a, C, A> { self._start_date = new_value.to_string(); self } @@ -25256,7 +25252,7 @@ impl<'a, C, NC, A> DataGaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// End date for fetching Analytics data. Request can should specify an end date formatted as YYYY-MM-DD, or as a relative date (e.g., today, yesterday, or 7daysAgo). The default value is yesterday. - pub fn end_date(mut self, new_value: &str) -> DataGaGetCall<'a, C, NC, A> { + pub fn end_date(mut self, new_value: &str) -> DataGaGetCall<'a, C, A> { self._end_date = new_value.to_string(); self } @@ -25266,7 +25262,7 @@ impl<'a, C, NC, A> DataGaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// A comma-separated list of Analytics metrics. E.g., 'ga:sessions,ga:pageviews'. At least one metric must be specified. - pub fn metrics(mut self, new_value: &str) -> DataGaGetCall<'a, C, NC, A> { + pub fn metrics(mut self, new_value: &str) -> DataGaGetCall<'a, C, A> { self._metrics = new_value.to_string(); self } @@ -25274,7 +25270,7 @@ impl<'a, C, NC, A> DataGaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// An index of the first entity to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter. - pub fn start_index(mut self, new_value: i32) -> DataGaGetCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> DataGaGetCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -25282,7 +25278,7 @@ impl<'a, C, NC, A> DataGaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// A comma-separated list of dimensions or metrics that determine the sort order for Analytics data. - pub fn sort(mut self, new_value: &str) -> DataGaGetCall<'a, C, NC, A> { + pub fn sort(mut self, new_value: &str) -> DataGaGetCall<'a, C, A> { self._sort = Some(new_value.to_string()); self } @@ -25290,7 +25286,7 @@ impl<'a, C, NC, A> DataGaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// An Analytics segment to be applied to data. - pub fn segment(mut self, new_value: &str) -> DataGaGetCall<'a, C, NC, A> { + pub fn segment(mut self, new_value: &str) -> DataGaGetCall<'a, C, A> { self._segment = Some(new_value.to_string()); self } @@ -25298,7 +25294,7 @@ impl<'a, C, NC, A> DataGaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The desired sampling level. - pub fn sampling_level(mut self, new_value: &str) -> DataGaGetCall<'a, C, NC, A> { + pub fn sampling_level(mut self, new_value: &str) -> DataGaGetCall<'a, C, A> { self._sampling_level = Some(new_value.to_string()); self } @@ -25306,7 +25302,7 @@ impl<'a, C, NC, A> DataGaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The selected format for the response. Default format is JSON. - pub fn output(mut self, new_value: &str) -> DataGaGetCall<'a, C, NC, A> { + pub fn output(mut self, new_value: &str) -> DataGaGetCall<'a, C, A> { self._output = Some(new_value.to_string()); self } @@ -25314,7 +25310,7 @@ impl<'a, C, NC, A> DataGaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The maximum number of entries to include in this feed. - pub fn max_results(mut self, new_value: i32) -> DataGaGetCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> DataGaGetCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -25322,7 +25318,7 @@ impl<'a, C, NC, A> DataGaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// A comma-separated list of dimension or metric filters to be applied to Analytics data. - pub fn filters(mut self, new_value: &str) -> DataGaGetCall<'a, C, NC, A> { + pub fn filters(mut self, new_value: &str) -> DataGaGetCall<'a, C, A> { self._filters = Some(new_value.to_string()); self } @@ -25330,7 +25326,7 @@ impl<'a, C, NC, A> DataGaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// A comma-separated list of Analytics dimensions. E.g., 'ga:browser,ga:city'. - pub fn dimensions(mut self, new_value: &str) -> DataGaGetCall<'a, C, NC, A> { + pub fn dimensions(mut self, new_value: &str) -> DataGaGetCall<'a, C, A> { self._dimensions = Some(new_value.to_string()); self } @@ -25341,7 +25337,7 @@ impl<'a, C, NC, A> DataGaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DataGaGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DataGaGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -25362,7 +25358,7 @@ impl<'a, C, NC, A> DataGaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DataGaGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DataGaGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -25379,7 +25375,7 @@ impl<'a, C, NC, A> DataGaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DataGaGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DataGaGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -25421,10 +25417,10 @@ impl<'a, C, NC, A> DataGaGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct DataRealtimeGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DataRealtimeGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _ids: String, _metrics: String, _sort: Option, @@ -25436,9 +25432,9 @@ pub struct DataRealtimeGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DataRealtimeGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DataRealtimeGetCall<'a, C, A> {} -impl<'a, C, NC, A> DataRealtimeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DataRealtimeGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -25559,7 +25555,7 @@ impl<'a, C, NC, A> DataRealtimeGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Unique table ID for retrieving real time data. Table ID is of the form ga:XXXX, where XXXX is the Analytics view (profile) ID. - pub fn ids(mut self, new_value: &str) -> DataRealtimeGetCall<'a, C, NC, A> { + pub fn ids(mut self, new_value: &str) -> DataRealtimeGetCall<'a, C, A> { self._ids = new_value.to_string(); self } @@ -25569,7 +25565,7 @@ impl<'a, C, NC, A> DataRealtimeGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// A comma-separated list of real time metrics. E.g., 'rt:activeUsers'. At least one metric must be specified. - pub fn metrics(mut self, new_value: &str) -> DataRealtimeGetCall<'a, C, NC, A> { + pub fn metrics(mut self, new_value: &str) -> DataRealtimeGetCall<'a, C, A> { self._metrics = new_value.to_string(); self } @@ -25577,7 +25573,7 @@ impl<'a, C, NC, A> DataRealtimeGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// A comma-separated list of dimensions or metrics that determine the sort order for real time data. - pub fn sort(mut self, new_value: &str) -> DataRealtimeGetCall<'a, C, NC, A> { + pub fn sort(mut self, new_value: &str) -> DataRealtimeGetCall<'a, C, A> { self._sort = Some(new_value.to_string()); self } @@ -25585,7 +25581,7 @@ impl<'a, C, NC, A> DataRealtimeGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The maximum number of entries to include in this feed. - pub fn max_results(mut self, new_value: i32) -> DataRealtimeGetCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> DataRealtimeGetCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -25593,7 +25589,7 @@ impl<'a, C, NC, A> DataRealtimeGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// A comma-separated list of dimension or metric filters to be applied to real time data. - pub fn filters(mut self, new_value: &str) -> DataRealtimeGetCall<'a, C, NC, A> { + pub fn filters(mut self, new_value: &str) -> DataRealtimeGetCall<'a, C, A> { self._filters = Some(new_value.to_string()); self } @@ -25601,7 +25597,7 @@ impl<'a, C, NC, A> DataRealtimeGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// A comma-separated list of real time dimensions. E.g., 'rt:medium,rt:city'. - pub fn dimensions(mut self, new_value: &str) -> DataRealtimeGetCall<'a, C, NC, A> { + pub fn dimensions(mut self, new_value: &str) -> DataRealtimeGetCall<'a, C, A> { self._dimensions = Some(new_value.to_string()); self } @@ -25612,7 +25608,7 @@ impl<'a, C, NC, A> DataRealtimeGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DataRealtimeGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DataRealtimeGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -25633,7 +25629,7 @@ impl<'a, C, NC, A> DataRealtimeGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DataRealtimeGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DataRealtimeGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -25650,7 +25646,7 @@ impl<'a, C, NC, A> DataRealtimeGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DataRealtimeGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DataRealtimeGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -25694,19 +25690,19 @@ impl<'a, C, NC, A> DataRealtimeGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct ProvisioningCreateAccountTicketCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProvisioningCreateAccountTicketCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _request: AccountTicket, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProvisioningCreateAccountTicketCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProvisioningCreateAccountTicketCall<'a, C, A> {} -impl<'a, C, NC, A> ProvisioningCreateAccountTicketCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProvisioningCreateAccountTicketCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -25820,7 +25816,7 @@ impl<'a, C, NC, A> ProvisioningCreateAccountTicketCall<'a, C, NC, A> where NC: h /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AccountTicket) -> ProvisioningCreateAccountTicketCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AccountTicket) -> ProvisioningCreateAccountTicketCall<'a, C, A> { self._request = new_value.clone(); self } @@ -25831,7 +25827,7 @@ impl<'a, C, NC, A> ProvisioningCreateAccountTicketCall<'a, C, NC, A> where NC: h /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProvisioningCreateAccountTicketCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProvisioningCreateAccountTicketCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -25852,7 +25848,7 @@ impl<'a, C, NC, A> ProvisioningCreateAccountTicketCall<'a, C, NC, A> where NC: h /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProvisioningCreateAccountTicketCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProvisioningCreateAccountTicketCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -25869,7 +25865,7 @@ impl<'a, C, NC, A> ProvisioningCreateAccountTicketCall<'a, C, NC, A> where NC: h /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProvisioningCreateAccountTicketCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProvisioningCreateAccountTicketCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -25907,19 +25903,19 @@ impl<'a, C, NC, A> ProvisioningCreateAccountTicketCall<'a, C, NC, A> where NC: h /// .doit(); /// # } /// ``` -pub struct MetadataColumnListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MetadataColumnListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Analytics, + hub: &'a Analytics, _report_type: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MetadataColumnListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MetadataColumnListCall<'a, C, A> {} -impl<'a, C, NC, A> MetadataColumnListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MetadataColumnListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -26051,7 +26047,7 @@ impl<'a, C, NC, A> MetadataColumnListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Report type. Allowed Values: 'ga'. Where 'ga' corresponds to the Core Reporting API - pub fn report_type(mut self, new_value: &str) -> MetadataColumnListCall<'a, C, NC, A> { + pub fn report_type(mut self, new_value: &str) -> MetadataColumnListCall<'a, C, A> { self._report_type = new_value.to_string(); self } @@ -26062,7 +26058,7 @@ impl<'a, C, NC, A> MetadataColumnListCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MetadataColumnListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MetadataColumnListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -26083,7 +26079,7 @@ impl<'a, C, NC, A> MetadataColumnListCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MetadataColumnListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MetadataColumnListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -26100,7 +26096,7 @@ impl<'a, C, NC, A> MetadataColumnListCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MetadataColumnListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MetadataColumnListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/androidenterprise1/Cargo.toml b/gen/androidenterprise1/Cargo.toml index 15a69ecd740..d0d6e0ebddd 100644 --- a/gen/androidenterprise1/Cargo.toml +++ b/gen/androidenterprise1/Cargo.toml @@ -4,11 +4,11 @@ [package] name = "google-androidenterprise1" -version = "0.1.4+20150309" +version = "0.1.5+20150309" authors = ["Sebastian Thiel "] description = "A complete library to interact with Android Enterprise (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/androidenterprise1" -documentation = "http://byron.github.io/google-apis-rs/google-androidenterprise1" +documentation = "http://byron.github.io/google-apis-rs/google_androidenterprise1" license = "MIT" keywords = ["androidenterprise", "google", "protocol", "web", "api"] diff --git a/gen/androidenterprise1/README.md b/gen/androidenterprise1/README.md index a3c708ffa1d..f562663f852 100644 --- a/gen/androidenterprise1/README.md +++ b/gen/androidenterprise1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-androidenterprise1` library allows access to all features of the *Google Android Enterprise* service. -This documentation was generated from *Android Enterprise* crate version *0.1.4+20150309*, where *20150309* is the exact revision of the *androidenterprise:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *Android Enterprise* crate version *0.1.5+20150309*, where *20150309* is the exact revision of the *androidenterprise:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. # Features Handle the following *Resources* with ease from the central [hub](http://byron.github.io/google-apis-rs/google-androidenterprise1/struct.AndroidEnterprise.html) ... diff --git a/gen/androidenterprise1/src/cmn.rs b/gen/androidenterprise1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/androidenterprise1/src/cmn.rs +++ b/gen/androidenterprise1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/androidenterprise1/src/lib.rs b/gen/androidenterprise1/src/lib.rs index 6e9339dab92..92f6fd68901 100644 --- a/gen/androidenterprise1/src/lib.rs +++ b/gen/androidenterprise1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *Android Enterprise* crate version *0.1.4+20150309*, where *20150309* is the exact revision of the *androidenterprise:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *Android Enterprise* crate version *0.1.5+20150309*, where *20150309* is the exact revision of the *androidenterprise:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/master/gen/androidenterprise1). //! # Features //! @@ -217,7 +217,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -314,64 +313,61 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct AndroidEnterprise { +pub struct AndroidEnterprise { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for AndroidEnterprise {} +impl<'a, C, A> Hub for AndroidEnterprise {} -impl<'a, C, NC, A> AndroidEnterprise - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AndroidEnterprise + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> AndroidEnterprise { + pub fn new(client: C, authenticator: A) -> AndroidEnterprise { AndroidEnterprise { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn collections(&'a self) -> CollectionMethods<'a, C, NC, A> { + pub fn collections(&'a self) -> CollectionMethods<'a, C, A> { CollectionMethods { hub: &self } } - pub fn collectionviewers(&'a self) -> CollectionviewerMethods<'a, C, NC, A> { + pub fn collectionviewers(&'a self) -> CollectionviewerMethods<'a, C, A> { CollectionviewerMethods { hub: &self } } - pub fn devices(&'a self) -> DeviceMethods<'a, C, NC, A> { + pub fn devices(&'a self) -> DeviceMethods<'a, C, A> { DeviceMethods { hub: &self } } - pub fn enterprises(&'a self) -> EnterpriseMethods<'a, C, NC, A> { + pub fn enterprises(&'a self) -> EnterpriseMethods<'a, C, A> { EnterpriseMethods { hub: &self } } - pub fn entitlements(&'a self) -> EntitlementMethods<'a, C, NC, A> { + pub fn entitlements(&'a self) -> EntitlementMethods<'a, C, A> { EntitlementMethods { hub: &self } } - pub fn grouplicenses(&'a self) -> GrouplicenseMethods<'a, C, NC, A> { + pub fn grouplicenses(&'a self) -> GrouplicenseMethods<'a, C, A> { GrouplicenseMethods { hub: &self } } - pub fn grouplicenseusers(&'a self) -> GrouplicenseuserMethods<'a, C, NC, A> { + pub fn grouplicenseusers(&'a self) -> GrouplicenseuserMethods<'a, C, A> { GrouplicenseuserMethods { hub: &self } } - pub fn installs(&'a self) -> InstallMethods<'a, C, NC, A> { + pub fn installs(&'a self) -> InstallMethods<'a, C, A> { InstallMethods { hub: &self } } - pub fn permissions(&'a self) -> PermissionMethods<'a, C, NC, A> { + pub fn permissions(&'a self) -> PermissionMethods<'a, C, A> { PermissionMethods { hub: &self } } - pub fn products(&'a self) -> ProductMethods<'a, C, NC, A> { + pub fn products(&'a self) -> ProductMethods<'a, C, A> { ProductMethods { hub: &self } } - pub fn users(&'a self) -> UserMethods<'a, C, NC, A> { + pub fn users(&'a self) -> UserMethods<'a, C, A> { UserMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -1109,15 +1105,15 @@ impl ResponseResult for GroupLicensesListResponse {} /// let rb = hub.collectionviewers(); /// # } /// ``` -pub struct CollectionviewerMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CollectionviewerMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, } -impl<'a, C, NC, A> MethodsBuilder for CollectionviewerMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CollectionviewerMethods<'a, C, A> {} -impl<'a, C, NC, A> CollectionviewerMethods<'a, C, NC, A> { +impl<'a, C, A> CollectionviewerMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1128,7 +1124,7 @@ impl<'a, C, NC, A> CollectionviewerMethods<'a, C, NC, A> { /// * `enterpriseId` - The ID of the enterprise. /// * `collectionId` - The ID of the collection. /// * `userId` - The ID of the user. - pub fn delete(&self, enterprise_id: &str, collection_id: &str, user_id: &str) -> CollectionviewerDeleteCall<'a, C, NC, A> { + pub fn delete(&self, enterprise_id: &str, collection_id: &str, user_id: &str) -> CollectionviewerDeleteCall<'a, C, A> { CollectionviewerDeleteCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -1150,7 +1146,7 @@ impl<'a, C, NC, A> CollectionviewerMethods<'a, C, NC, A> { /// * `enterpriseId` - The ID of the enterprise. /// * `collectionId` - The ID of the collection. /// * `userId` - The ID of the user. - pub fn patch(&self, request: &User, enterprise_id: &str, collection_id: &str, user_id: &str) -> CollectionviewerPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &User, enterprise_id: &str, collection_id: &str, user_id: &str) -> CollectionviewerPatchCall<'a, C, A> { CollectionviewerPatchCall { hub: self.hub, _request: request.clone(), @@ -1172,7 +1168,7 @@ impl<'a, C, NC, A> CollectionviewerMethods<'a, C, NC, A> { /// * `enterpriseId` - The ID of the enterprise. /// * `collectionId` - The ID of the collection. /// * `userId` - The ID of the user. - pub fn get(&self, enterprise_id: &str, collection_id: &str, user_id: &str) -> CollectionviewerGetCall<'a, C, NC, A> { + pub fn get(&self, enterprise_id: &str, collection_id: &str, user_id: &str) -> CollectionviewerGetCall<'a, C, A> { CollectionviewerGetCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -1192,7 +1188,7 @@ impl<'a, C, NC, A> CollectionviewerMethods<'a, C, NC, A> { /// /// * `enterpriseId` - The ID of the enterprise. /// * `collectionId` - The ID of the collection. - pub fn list(&self, enterprise_id: &str, collection_id: &str) -> CollectionviewerListCall<'a, C, NC, A> { + pub fn list(&self, enterprise_id: &str, collection_id: &str) -> CollectionviewerListCall<'a, C, A> { CollectionviewerListCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -1213,7 +1209,7 @@ impl<'a, C, NC, A> CollectionviewerMethods<'a, C, NC, A> { /// * `enterpriseId` - The ID of the enterprise. /// * `collectionId` - The ID of the collection. /// * `userId` - The ID of the user. - pub fn update(&self, request: &User, enterprise_id: &str, collection_id: &str, user_id: &str) -> CollectionviewerUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &User, enterprise_id: &str, collection_id: &str, user_id: &str) -> CollectionviewerUpdateCall<'a, C, A> { CollectionviewerUpdateCall { hub: self.hub, _request: request.clone(), @@ -1257,15 +1253,15 @@ impl<'a, C, NC, A> CollectionviewerMethods<'a, C, NC, A> { /// let rb = hub.users(); /// # } /// ``` -pub struct UserMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, } -impl<'a, C, NC, A> MethodsBuilder for UserMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for UserMethods<'a, C, A> {} -impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { +impl<'a, C, A> UserMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1275,7 +1271,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `enterpriseId` - The ID of the enterprise. /// * `userId` - The ID of the user. - pub fn revoke_token(&self, enterprise_id: &str, user_id: &str) -> UserRevokeTokenCall<'a, C, NC, A> { + pub fn revoke_token(&self, enterprise_id: &str, user_id: &str) -> UserRevokeTokenCall<'a, C, A> { UserRevokeTokenCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -1294,7 +1290,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `enterpriseId` - The ID of the enterprise. /// * `userId` - The ID of the user. - pub fn get(&self, enterprise_id: &str, user_id: &str) -> UserGetCall<'a, C, NC, A> { + pub fn get(&self, enterprise_id: &str, user_id: &str) -> UserGetCall<'a, C, A> { UserGetCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -1313,7 +1309,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `enterpriseId` - The ID of the enterprise. /// * `email` - The exact primary email address of the user to look up. - pub fn list(&self, enterprise_id: &str, email: &str) -> UserListCall<'a, C, NC, A> { + pub fn list(&self, enterprise_id: &str, email: &str) -> UserListCall<'a, C, A> { UserListCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -1332,7 +1328,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `enterpriseId` - The ID of the enterprise. /// * `userId` - The ID of the user. - pub fn generate_token(&self, enterprise_id: &str, user_id: &str) -> UserGenerateTokenCall<'a, C, NC, A> { + pub fn generate_token(&self, enterprise_id: &str, user_id: &str) -> UserGenerateTokenCall<'a, C, A> { UserGenerateTokenCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -1374,15 +1370,15 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// let rb = hub.installs(); /// # } /// ``` -pub struct InstallMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstallMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, } -impl<'a, C, NC, A> MethodsBuilder for InstallMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for InstallMethods<'a, C, A> {} -impl<'a, C, NC, A> InstallMethods<'a, C, NC, A> { +impl<'a, C, A> InstallMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1395,7 +1391,7 @@ impl<'a, C, NC, A> InstallMethods<'a, C, NC, A> { /// * `userId` - The ID of the user. /// * `deviceId` - The Android ID of the device. /// * `installId` - The ID of the product represented by the install, e.g. "app:com.google.android.gm". - pub fn patch(&self, request: &Install, enterprise_id: &str, user_id: &str, device_id: &str, install_id: &str) -> InstallPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Install, enterprise_id: &str, user_id: &str, device_id: &str, install_id: &str) -> InstallPatchCall<'a, C, A> { InstallPatchCall { hub: self.hub, _request: request.clone(), @@ -1419,7 +1415,7 @@ impl<'a, C, NC, A> InstallMethods<'a, C, NC, A> { /// * `userId` - The ID of the user. /// * `deviceId` - The Android ID of the device. /// * `installId` - The ID of the product represented by the install, e.g. "app:com.google.android.gm". - pub fn get(&self, enterprise_id: &str, user_id: &str, device_id: &str, install_id: &str) -> InstallGetCall<'a, C, NC, A> { + pub fn get(&self, enterprise_id: &str, user_id: &str, device_id: &str, install_id: &str) -> InstallGetCall<'a, C, A> { InstallGetCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -1441,7 +1437,7 @@ impl<'a, C, NC, A> InstallMethods<'a, C, NC, A> { /// * `enterpriseId` - The ID of the enterprise. /// * `userId` - The ID of the user. /// * `deviceId` - The Android ID of the device. - pub fn list(&self, enterprise_id: &str, user_id: &str, device_id: &str) -> InstallListCall<'a, C, NC, A> { + pub fn list(&self, enterprise_id: &str, user_id: &str, device_id: &str) -> InstallListCall<'a, C, A> { InstallListCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -1463,7 +1459,7 @@ impl<'a, C, NC, A> InstallMethods<'a, C, NC, A> { /// * `userId` - The ID of the user. /// * `deviceId` - The Android ID of the device. /// * `installId` - The ID of the product represented by the install, e.g. "app:com.google.android.gm". - pub fn delete(&self, enterprise_id: &str, user_id: &str, device_id: &str, install_id: &str) -> InstallDeleteCall<'a, C, NC, A> { + pub fn delete(&self, enterprise_id: &str, user_id: &str, device_id: &str, install_id: &str) -> InstallDeleteCall<'a, C, A> { InstallDeleteCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -1487,7 +1483,7 @@ impl<'a, C, NC, A> InstallMethods<'a, C, NC, A> { /// * `userId` - The ID of the user. /// * `deviceId` - The Android ID of the device. /// * `installId` - The ID of the product represented by the install, e.g. "app:com.google.android.gm". - pub fn update(&self, request: &Install, enterprise_id: &str, user_id: &str, device_id: &str, install_id: &str) -> InstallUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Install, enterprise_id: &str, user_id: &str, device_id: &str, install_id: &str) -> InstallUpdateCall<'a, C, A> { InstallUpdateCall { hub: self.hub, _request: request.clone(), @@ -1532,15 +1528,15 @@ impl<'a, C, NC, A> InstallMethods<'a, C, NC, A> { /// let rb = hub.devices(); /// # } /// ``` -pub struct DeviceMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DeviceMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, } -impl<'a, C, NC, A> MethodsBuilder for DeviceMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for DeviceMethods<'a, C, A> {} -impl<'a, C, NC, A> DeviceMethods<'a, C, NC, A> { +impl<'a, C, A> DeviceMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1552,7 +1548,7 @@ impl<'a, C, NC, A> DeviceMethods<'a, C, NC, A> { /// * `enterpriseId` - The ID of the enterprise. /// * `userId` - The ID of the user. /// * `deviceId` - The ID of the device. - pub fn set_state(&self, request: &DeviceState, enterprise_id: &str, user_id: &str, device_id: &str) -> DeviceSetStateCall<'a, C, NC, A> { + pub fn set_state(&self, request: &DeviceState, enterprise_id: &str, user_id: &str, device_id: &str) -> DeviceSetStateCall<'a, C, A> { DeviceSetStateCall { hub: self.hub, _request: request.clone(), @@ -1574,7 +1570,7 @@ impl<'a, C, NC, A> DeviceMethods<'a, C, NC, A> { /// * `enterpriseId` - The ID of the enterprise. /// * `userId` - The ID of the user. /// * `deviceId` - The ID of the device. - pub fn get_state(&self, enterprise_id: &str, user_id: &str, device_id: &str) -> DeviceGetStateCall<'a, C, NC, A> { + pub fn get_state(&self, enterprise_id: &str, user_id: &str, device_id: &str) -> DeviceGetStateCall<'a, C, A> { DeviceGetStateCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -1594,7 +1590,7 @@ impl<'a, C, NC, A> DeviceMethods<'a, C, NC, A> { /// /// * `enterpriseId` - The ID of the enterprise. /// * `userId` - The ID of the user. - pub fn list(&self, enterprise_id: &str, user_id: &str) -> DeviceListCall<'a, C, NC, A> { + pub fn list(&self, enterprise_id: &str, user_id: &str) -> DeviceListCall<'a, C, A> { DeviceListCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -1614,7 +1610,7 @@ impl<'a, C, NC, A> DeviceMethods<'a, C, NC, A> { /// * `enterpriseId` - The ID of the enterprise. /// * `userId` - The ID of the user. /// * `deviceId` - The ID of the device. - pub fn get(&self, enterprise_id: &str, user_id: &str, device_id: &str) -> DeviceGetCall<'a, C, NC, A> { + pub fn get(&self, enterprise_id: &str, user_id: &str, device_id: &str) -> DeviceGetCall<'a, C, A> { DeviceGetCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -1657,15 +1653,15 @@ impl<'a, C, NC, A> DeviceMethods<'a, C, NC, A> { /// let rb = hub.enterprises(); /// # } /// ``` -pub struct EnterpriseMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EnterpriseMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, } -impl<'a, C, NC, A> MethodsBuilder for EnterpriseMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for EnterpriseMethods<'a, C, A> {} -impl<'a, C, NC, A> EnterpriseMethods<'a, C, NC, A> { +impl<'a, C, A> EnterpriseMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1674,7 +1670,7 @@ impl<'a, C, NC, A> EnterpriseMethods<'a, C, NC, A> { /// # Arguments /// /// * `enterpriseId` - The ID of the enterprise. - pub fn unenroll(&self, enterprise_id: &str) -> EnterpriseUnenrollCall<'a, C, NC, A> { + pub fn unenroll(&self, enterprise_id: &str) -> EnterpriseUnenrollCall<'a, C, A> { EnterpriseUnenrollCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -1692,7 +1688,7 @@ impl<'a, C, NC, A> EnterpriseMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `token` - The token provided by the enterprise to register the MDM. - pub fn insert(&self, request: &Enterprise, token: &str) -> EnterpriseInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Enterprise, token: &str) -> EnterpriseInsertCall<'a, C, A> { EnterpriseInsertCall { hub: self.hub, _request: request.clone(), @@ -1710,7 +1706,7 @@ impl<'a, C, NC, A> EnterpriseMethods<'a, C, NC, A> { /// # Arguments /// /// * `domain` - The exact primary domain name of the enterprise to look up. - pub fn list(&self, domain: &str) -> EnterpriseListCall<'a, C, NC, A> { + pub fn list(&self, domain: &str) -> EnterpriseListCall<'a, C, A> { EnterpriseListCall { hub: self.hub, _domain: domain.to_string(), @@ -1727,7 +1723,7 @@ impl<'a, C, NC, A> EnterpriseMethods<'a, C, NC, A> { /// # Arguments /// /// * `enterpriseId` - The ID of the enterprise. - pub fn get(&self, enterprise_id: &str) -> EnterpriseGetCall<'a, C, NC, A> { + pub fn get(&self, enterprise_id: &str) -> EnterpriseGetCall<'a, C, A> { EnterpriseGetCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -1745,7 +1741,7 @@ impl<'a, C, NC, A> EnterpriseMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `token` - The token provided by the enterprise to register the MDM. - pub fn enroll(&self, request: &Enterprise, token: &str) -> EnterpriseEnrollCall<'a, C, NC, A> { + pub fn enroll(&self, request: &Enterprise, token: &str) -> EnterpriseEnrollCall<'a, C, A> { EnterpriseEnrollCall { hub: self.hub, _request: request.clone(), @@ -1764,7 +1760,7 @@ impl<'a, C, NC, A> EnterpriseMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `enterpriseId` - The ID of the enterprise. - pub fn set_account(&self, request: &EnterpriseAccount, enterprise_id: &str) -> EnterpriseSetAccountCall<'a, C, NC, A> { + pub fn set_account(&self, request: &EnterpriseAccount, enterprise_id: &str) -> EnterpriseSetAccountCall<'a, C, A> { EnterpriseSetAccountCall { hub: self.hub, _request: request.clone(), @@ -1782,7 +1778,7 @@ impl<'a, C, NC, A> EnterpriseMethods<'a, C, NC, A> { /// # Arguments /// /// * `enterpriseId` - The ID of the enterprise. - pub fn delete(&self, enterprise_id: &str) -> EnterpriseDeleteCall<'a, C, NC, A> { + pub fn delete(&self, enterprise_id: &str) -> EnterpriseDeleteCall<'a, C, A> { EnterpriseDeleteCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -1823,15 +1819,15 @@ impl<'a, C, NC, A> EnterpriseMethods<'a, C, NC, A> { /// let rb = hub.collections(); /// # } /// ``` -pub struct CollectionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CollectionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, } -impl<'a, C, NC, A> MethodsBuilder for CollectionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CollectionMethods<'a, C, A> {} -impl<'a, C, NC, A> CollectionMethods<'a, C, NC, A> { +impl<'a, C, A> CollectionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1841,7 +1837,7 @@ impl<'a, C, NC, A> CollectionMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `enterpriseId` - The ID of the enterprise. - pub fn insert(&self, request: &Collection, enterprise_id: &str) -> CollectionInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Collection, enterprise_id: &str) -> CollectionInsertCall<'a, C, A> { CollectionInsertCall { hub: self.hub, _request: request.clone(), @@ -1861,7 +1857,7 @@ impl<'a, C, NC, A> CollectionMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `enterpriseId` - The ID of the enterprise. /// * `collectionId` - The ID of the collection. - pub fn patch(&self, request: &Collection, enterprise_id: &str, collection_id: &str) -> CollectionPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Collection, enterprise_id: &str, collection_id: &str) -> CollectionPatchCall<'a, C, A> { CollectionPatchCall { hub: self.hub, _request: request.clone(), @@ -1882,7 +1878,7 @@ impl<'a, C, NC, A> CollectionMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `enterpriseId` - The ID of the enterprise. /// * `collectionId` - The ID of the collection. - pub fn update(&self, request: &Collection, enterprise_id: &str, collection_id: &str) -> CollectionUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Collection, enterprise_id: &str, collection_id: &str) -> CollectionUpdateCall<'a, C, A> { CollectionUpdateCall { hub: self.hub, _request: request.clone(), @@ -1901,7 +1897,7 @@ impl<'a, C, NC, A> CollectionMethods<'a, C, NC, A> { /// # Arguments /// /// * `enterpriseId` - The ID of the enterprise. - pub fn list(&self, enterprise_id: &str) -> CollectionListCall<'a, C, NC, A> { + pub fn list(&self, enterprise_id: &str) -> CollectionListCall<'a, C, A> { CollectionListCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -1919,7 +1915,7 @@ impl<'a, C, NC, A> CollectionMethods<'a, C, NC, A> { /// /// * `enterpriseId` - The ID of the enterprise. /// * `collectionId` - The ID of the collection. - pub fn get(&self, enterprise_id: &str, collection_id: &str) -> CollectionGetCall<'a, C, NC, A> { + pub fn get(&self, enterprise_id: &str, collection_id: &str) -> CollectionGetCall<'a, C, A> { CollectionGetCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -1938,7 +1934,7 @@ impl<'a, C, NC, A> CollectionMethods<'a, C, NC, A> { /// /// * `enterpriseId` - The ID of the enterprise. /// * `collectionId` - The ID of the collection. - pub fn delete(&self, enterprise_id: &str, collection_id: &str) -> CollectionDeleteCall<'a, C, NC, A> { + pub fn delete(&self, enterprise_id: &str, collection_id: &str) -> CollectionDeleteCall<'a, C, A> { CollectionDeleteCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -1980,15 +1976,15 @@ impl<'a, C, NC, A> CollectionMethods<'a, C, NC, A> { /// let rb = hub.grouplicenseusers(); /// # } /// ``` -pub struct GrouplicenseuserMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GrouplicenseuserMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, } -impl<'a, C, NC, A> MethodsBuilder for GrouplicenseuserMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for GrouplicenseuserMethods<'a, C, A> {} -impl<'a, C, NC, A> GrouplicenseuserMethods<'a, C, NC, A> { +impl<'a, C, A> GrouplicenseuserMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1998,7 +1994,7 @@ impl<'a, C, NC, A> GrouplicenseuserMethods<'a, C, NC, A> { /// /// * `enterpriseId` - The ID of the enterprise. /// * `groupLicenseId` - The ID of the product the group license is for, e.g. "app:com.google.android.gm". - pub fn list(&self, enterprise_id: &str, group_license_id: &str) -> GrouplicenseuserListCall<'a, C, NC, A> { + pub fn list(&self, enterprise_id: &str, group_license_id: &str) -> GrouplicenseuserListCall<'a, C, A> { GrouplicenseuserListCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -2040,15 +2036,15 @@ impl<'a, C, NC, A> GrouplicenseuserMethods<'a, C, NC, A> { /// let rb = hub.entitlements(); /// # } /// ``` -pub struct EntitlementMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EntitlementMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, } -impl<'a, C, NC, A> MethodsBuilder for EntitlementMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for EntitlementMethods<'a, C, A> {} -impl<'a, C, NC, A> EntitlementMethods<'a, C, NC, A> { +impl<'a, C, A> EntitlementMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2060,7 +2056,7 @@ impl<'a, C, NC, A> EntitlementMethods<'a, C, NC, A> { /// * `enterpriseId` - The ID of the enterprise. /// * `userId` - The ID of the user. /// * `entitlementId` - The ID of the entitlement, e.g. "app:com.google.android.gm". - pub fn update(&self, request: &Entitlement, enterprise_id: &str, user_id: &str, entitlement_id: &str) -> EntitlementUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Entitlement, enterprise_id: &str, user_id: &str, entitlement_id: &str) -> EntitlementUpdateCall<'a, C, A> { EntitlementUpdateCall { hub: self.hub, _request: request.clone(), @@ -2082,7 +2078,7 @@ impl<'a, C, NC, A> EntitlementMethods<'a, C, NC, A> { /// /// * `enterpriseId` - The ID of the enterprise. /// * `userId` - The ID of the user. - pub fn list(&self, enterprise_id: &str, user_id: &str) -> EntitlementListCall<'a, C, NC, A> { + pub fn list(&self, enterprise_id: &str, user_id: &str) -> EntitlementListCall<'a, C, A> { EntitlementListCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -2102,7 +2098,7 @@ impl<'a, C, NC, A> EntitlementMethods<'a, C, NC, A> { /// * `enterpriseId` - The ID of the enterprise. /// * `userId` - The ID of the user. /// * `entitlementId` - The ID of the entitlement, e.g. "app:com.google.android.gm". - pub fn get(&self, enterprise_id: &str, user_id: &str, entitlement_id: &str) -> EntitlementGetCall<'a, C, NC, A> { + pub fn get(&self, enterprise_id: &str, user_id: &str, entitlement_id: &str) -> EntitlementGetCall<'a, C, A> { EntitlementGetCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -2124,7 +2120,7 @@ impl<'a, C, NC, A> EntitlementMethods<'a, C, NC, A> { /// * `enterpriseId` - The ID of the enterprise. /// * `userId` - The ID of the user. /// * `entitlementId` - The ID of the entitlement, e.g. "app:com.google.android.gm". - pub fn patch(&self, request: &Entitlement, enterprise_id: &str, user_id: &str, entitlement_id: &str) -> EntitlementPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Entitlement, enterprise_id: &str, user_id: &str, entitlement_id: &str) -> EntitlementPatchCall<'a, C, A> { EntitlementPatchCall { hub: self.hub, _request: request.clone(), @@ -2147,7 +2143,7 @@ impl<'a, C, NC, A> EntitlementMethods<'a, C, NC, A> { /// * `enterpriseId` - The ID of the enterprise. /// * `userId` - The ID of the user. /// * `entitlementId` - The ID of the entitlement, e.g. "app:com.google.android.gm". - pub fn delete(&self, enterprise_id: &str, user_id: &str, entitlement_id: &str) -> EntitlementDeleteCall<'a, C, NC, A> { + pub fn delete(&self, enterprise_id: &str, user_id: &str, entitlement_id: &str) -> EntitlementDeleteCall<'a, C, A> { EntitlementDeleteCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -2190,15 +2186,15 @@ impl<'a, C, NC, A> EntitlementMethods<'a, C, NC, A> { /// let rb = hub.products(); /// # } /// ``` -pub struct ProductMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProductMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, } -impl<'a, C, NC, A> MethodsBuilder for ProductMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ProductMethods<'a, C, A> {} -impl<'a, C, NC, A> ProductMethods<'a, C, NC, A> { +impl<'a, C, A> ProductMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2208,7 +2204,7 @@ impl<'a, C, NC, A> ProductMethods<'a, C, NC, A> { /// /// * `enterpriseId` - The ID of the enterprise. /// * `productId` - The ID of the product. - pub fn get_permissions(&self, enterprise_id: &str, product_id: &str) -> ProductGetPermissionCall<'a, C, NC, A> { + pub fn get_permissions(&self, enterprise_id: &str, product_id: &str) -> ProductGetPermissionCall<'a, C, A> { ProductGetPermissionCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -2227,7 +2223,7 @@ impl<'a, C, NC, A> ProductMethods<'a, C, NC, A> { /// /// * `enterpriseId` - The ID of the enterprise. /// * `productId` - The ID of the product, e.g. "app:com.google.android.gm". - pub fn get(&self, enterprise_id: &str, product_id: &str) -> ProductGetCall<'a, C, NC, A> { + pub fn get(&self, enterprise_id: &str, product_id: &str) -> ProductGetCall<'a, C, A> { ProductGetCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -2247,7 +2243,7 @@ impl<'a, C, NC, A> ProductMethods<'a, C, NC, A> { /// /// * `enterpriseId` - The ID of the enterprise. /// * `productId` - The ID of the product. - pub fn get_app_restrictions_schema(&self, enterprise_id: &str, product_id: &str) -> ProductGetAppRestrictionsSchemaCall<'a, C, NC, A> { + pub fn get_app_restrictions_schema(&self, enterprise_id: &str, product_id: &str) -> ProductGetAppRestrictionsSchemaCall<'a, C, A> { ProductGetAppRestrictionsSchemaCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -2268,7 +2264,7 @@ impl<'a, C, NC, A> ProductMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `enterpriseId` - The ID of the enterprise. /// * `productId` - The ID of the product. - pub fn update_permissions(&self, request: &ProductPermissions, enterprise_id: &str, product_id: &str) -> ProductUpdatePermissionCall<'a, C, NC, A> { + pub fn update_permissions(&self, request: &ProductPermissions, enterprise_id: &str, product_id: &str) -> ProductUpdatePermissionCall<'a, C, A> { ProductUpdatePermissionCall { hub: self.hub, _request: request.clone(), @@ -2311,15 +2307,15 @@ impl<'a, C, NC, A> ProductMethods<'a, C, NC, A> { /// let rb = hub.grouplicenses(); /// # } /// ``` -pub struct GrouplicenseMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GrouplicenseMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, } -impl<'a, C, NC, A> MethodsBuilder for GrouplicenseMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for GrouplicenseMethods<'a, C, A> {} -impl<'a, C, NC, A> GrouplicenseMethods<'a, C, NC, A> { +impl<'a, C, A> GrouplicenseMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2329,7 +2325,7 @@ impl<'a, C, NC, A> GrouplicenseMethods<'a, C, NC, A> { /// /// * `enterpriseId` - The ID of the enterprise. /// * `groupLicenseId` - The ID of the product the group license is for, e.g. "app:com.google.android.gm". - pub fn get(&self, enterprise_id: &str, group_license_id: &str) -> GrouplicenseGetCall<'a, C, NC, A> { + pub fn get(&self, enterprise_id: &str, group_license_id: &str) -> GrouplicenseGetCall<'a, C, A> { GrouplicenseGetCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -2347,7 +2343,7 @@ impl<'a, C, NC, A> GrouplicenseMethods<'a, C, NC, A> { /// # Arguments /// /// * `enterpriseId` - The ID of the enterprise. - pub fn list(&self, enterprise_id: &str) -> GrouplicenseListCall<'a, C, NC, A> { + pub fn list(&self, enterprise_id: &str) -> GrouplicenseListCall<'a, C, A> { GrouplicenseListCall { hub: self.hub, _enterprise_id: enterprise_id.to_string(), @@ -2388,15 +2384,15 @@ impl<'a, C, NC, A> GrouplicenseMethods<'a, C, NC, A> { /// let rb = hub.permissions(); /// # } /// ``` -pub struct PermissionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PermissionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, } -impl<'a, C, NC, A> MethodsBuilder for PermissionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PermissionMethods<'a, C, A> {} -impl<'a, C, NC, A> PermissionMethods<'a, C, NC, A> { +impl<'a, C, A> PermissionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2405,7 +2401,7 @@ impl<'a, C, NC, A> PermissionMethods<'a, C, NC, A> { /// # Arguments /// /// * `permissionId` - The ID of the permission. - pub fn get(&self, permission_id: &str) -> PermissionGetCall<'a, C, NC, A> { + pub fn get(&self, permission_id: &str) -> PermissionGetCall<'a, C, A> { PermissionGetCall { hub: self.hub, _permission_id: permission_id.to_string(), @@ -2455,10 +2451,10 @@ impl<'a, C, NC, A> PermissionMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct CollectionviewerDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CollectionviewerDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _collection_id: String, _user_id: String, @@ -2467,9 +2463,9 @@ pub struct CollectionviewerDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CollectionviewerDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CollectionviewerDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> CollectionviewerDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CollectionviewerDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2592,7 +2588,7 @@ impl<'a, C, NC, A> CollectionviewerDeleteCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> CollectionviewerDeleteCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> CollectionviewerDeleteCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -2602,7 +2598,7 @@ impl<'a, C, NC, A> CollectionviewerDeleteCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The ID of the collection. - pub fn collection_id(mut self, new_value: &str) -> CollectionviewerDeleteCall<'a, C, NC, A> { + pub fn collection_id(mut self, new_value: &str) -> CollectionviewerDeleteCall<'a, C, A> { self._collection_id = new_value.to_string(); self } @@ -2612,7 +2608,7 @@ impl<'a, C, NC, A> CollectionviewerDeleteCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The ID of the user. - pub fn user_id(mut self, new_value: &str) -> CollectionviewerDeleteCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> CollectionviewerDeleteCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -2623,7 +2619,7 @@ impl<'a, C, NC, A> CollectionviewerDeleteCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CollectionviewerDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CollectionviewerDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2644,7 +2640,7 @@ impl<'a, C, NC, A> CollectionviewerDeleteCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CollectionviewerDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CollectionviewerDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2661,7 +2657,7 @@ impl<'a, C, NC, A> CollectionviewerDeleteCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CollectionviewerDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CollectionviewerDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2705,10 +2701,10 @@ impl<'a, C, NC, A> CollectionviewerDeleteCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct CollectionviewerPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CollectionviewerPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _request: User, _enterprise_id: String, _collection_id: String, @@ -2718,9 +2714,9 @@ pub struct CollectionviewerPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CollectionviewerPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CollectionviewerPatchCall<'a, C, A> {} -impl<'a, C, NC, A> CollectionviewerPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CollectionviewerPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2861,7 +2857,7 @@ impl<'a, C, NC, A> CollectionviewerPatchCall<'a, C, NC, A> where NC: hyper::net: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &User) -> CollectionviewerPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &User) -> CollectionviewerPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2871,7 +2867,7 @@ impl<'a, C, NC, A> CollectionviewerPatchCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> CollectionviewerPatchCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> CollectionviewerPatchCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -2881,7 +2877,7 @@ impl<'a, C, NC, A> CollectionviewerPatchCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The ID of the collection. - pub fn collection_id(mut self, new_value: &str) -> CollectionviewerPatchCall<'a, C, NC, A> { + pub fn collection_id(mut self, new_value: &str) -> CollectionviewerPatchCall<'a, C, A> { self._collection_id = new_value.to_string(); self } @@ -2891,7 +2887,7 @@ impl<'a, C, NC, A> CollectionviewerPatchCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The ID of the user. - pub fn user_id(mut self, new_value: &str) -> CollectionviewerPatchCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> CollectionviewerPatchCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -2902,7 +2898,7 @@ impl<'a, C, NC, A> CollectionviewerPatchCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CollectionviewerPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CollectionviewerPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2923,7 +2919,7 @@ impl<'a, C, NC, A> CollectionviewerPatchCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CollectionviewerPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CollectionviewerPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2940,7 +2936,7 @@ impl<'a, C, NC, A> CollectionviewerPatchCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CollectionviewerPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CollectionviewerPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2978,10 +2974,10 @@ impl<'a, C, NC, A> CollectionviewerPatchCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct CollectionviewerGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CollectionviewerGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _collection_id: String, _user_id: String, @@ -2990,9 +2986,9 @@ pub struct CollectionviewerGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CollectionviewerGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CollectionviewerGetCall<'a, C, A> {} -impl<'a, C, NC, A> CollectionviewerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CollectionviewerGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3126,7 +3122,7 @@ impl<'a, C, NC, A> CollectionviewerGetCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> CollectionviewerGetCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> CollectionviewerGetCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -3136,7 +3132,7 @@ impl<'a, C, NC, A> CollectionviewerGetCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The ID of the collection. - pub fn collection_id(mut self, new_value: &str) -> CollectionviewerGetCall<'a, C, NC, A> { + pub fn collection_id(mut self, new_value: &str) -> CollectionviewerGetCall<'a, C, A> { self._collection_id = new_value.to_string(); self } @@ -3146,7 +3142,7 @@ impl<'a, C, NC, A> CollectionviewerGetCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The ID of the user. - pub fn user_id(mut self, new_value: &str) -> CollectionviewerGetCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> CollectionviewerGetCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -3157,7 +3153,7 @@ impl<'a, C, NC, A> CollectionviewerGetCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CollectionviewerGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CollectionviewerGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3178,7 +3174,7 @@ impl<'a, C, NC, A> CollectionviewerGetCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CollectionviewerGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CollectionviewerGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3195,7 +3191,7 @@ impl<'a, C, NC, A> CollectionviewerGetCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CollectionviewerGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CollectionviewerGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3233,10 +3229,10 @@ impl<'a, C, NC, A> CollectionviewerGetCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct CollectionviewerListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CollectionviewerListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _collection_id: String, _delegate: Option<&'a mut Delegate>, @@ -3244,9 +3240,9 @@ pub struct CollectionviewerListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CollectionviewerListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CollectionviewerListCall<'a, C, A> {} -impl<'a, C, NC, A> CollectionviewerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CollectionviewerListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3379,7 +3375,7 @@ impl<'a, C, NC, A> CollectionviewerListCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> CollectionviewerListCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> CollectionviewerListCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -3389,7 +3385,7 @@ impl<'a, C, NC, A> CollectionviewerListCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The ID of the collection. - pub fn collection_id(mut self, new_value: &str) -> CollectionviewerListCall<'a, C, NC, A> { + pub fn collection_id(mut self, new_value: &str) -> CollectionviewerListCall<'a, C, A> { self._collection_id = new_value.to_string(); self } @@ -3400,7 +3396,7 @@ impl<'a, C, NC, A> CollectionviewerListCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CollectionviewerListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CollectionviewerListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3421,7 +3417,7 @@ impl<'a, C, NC, A> CollectionviewerListCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CollectionviewerListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CollectionviewerListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3438,7 +3434,7 @@ impl<'a, C, NC, A> CollectionviewerListCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CollectionviewerListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CollectionviewerListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3482,10 +3478,10 @@ impl<'a, C, NC, A> CollectionviewerListCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct CollectionviewerUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CollectionviewerUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _request: User, _enterprise_id: String, _collection_id: String, @@ -3495,9 +3491,9 @@ pub struct CollectionviewerUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CollectionviewerUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CollectionviewerUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> CollectionviewerUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CollectionviewerUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3638,7 +3634,7 @@ impl<'a, C, NC, A> CollectionviewerUpdateCall<'a, C, NC, A> where NC: hyper::net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &User) -> CollectionviewerUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &User) -> CollectionviewerUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3648,7 +3644,7 @@ impl<'a, C, NC, A> CollectionviewerUpdateCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> CollectionviewerUpdateCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> CollectionviewerUpdateCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -3658,7 +3654,7 @@ impl<'a, C, NC, A> CollectionviewerUpdateCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The ID of the collection. - pub fn collection_id(mut self, new_value: &str) -> CollectionviewerUpdateCall<'a, C, NC, A> { + pub fn collection_id(mut self, new_value: &str) -> CollectionviewerUpdateCall<'a, C, A> { self._collection_id = new_value.to_string(); self } @@ -3668,7 +3664,7 @@ impl<'a, C, NC, A> CollectionviewerUpdateCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The ID of the user. - pub fn user_id(mut self, new_value: &str) -> CollectionviewerUpdateCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> CollectionviewerUpdateCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -3679,7 +3675,7 @@ impl<'a, C, NC, A> CollectionviewerUpdateCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CollectionviewerUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CollectionviewerUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3700,7 +3696,7 @@ impl<'a, C, NC, A> CollectionviewerUpdateCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CollectionviewerUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CollectionviewerUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3717,7 +3713,7 @@ impl<'a, C, NC, A> CollectionviewerUpdateCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CollectionviewerUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CollectionviewerUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3755,10 +3751,10 @@ impl<'a, C, NC, A> CollectionviewerUpdateCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct UserRevokeTokenCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserRevokeTokenCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _user_id: String, _delegate: Option<&'a mut Delegate>, @@ -3766,9 +3762,9 @@ pub struct UserRevokeTokenCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserRevokeTokenCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserRevokeTokenCall<'a, C, A> {} -impl<'a, C, NC, A> UserRevokeTokenCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserRevokeTokenCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3890,7 +3886,7 @@ impl<'a, C, NC, A> UserRevokeTokenCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> UserRevokeTokenCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> UserRevokeTokenCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -3900,7 +3896,7 @@ impl<'a, C, NC, A> UserRevokeTokenCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the user. - pub fn user_id(mut self, new_value: &str) -> UserRevokeTokenCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserRevokeTokenCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -3911,7 +3907,7 @@ impl<'a, C, NC, A> UserRevokeTokenCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserRevokeTokenCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserRevokeTokenCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3932,7 +3928,7 @@ impl<'a, C, NC, A> UserRevokeTokenCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserRevokeTokenCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserRevokeTokenCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3949,7 +3945,7 @@ impl<'a, C, NC, A> UserRevokeTokenCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserRevokeTokenCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserRevokeTokenCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3987,10 +3983,10 @@ impl<'a, C, NC, A> UserRevokeTokenCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct UserGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _user_id: String, _delegate: Option<&'a mut Delegate>, @@ -3998,9 +3994,9 @@ pub struct UserGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserGetCall<'a, C, A> {} -impl<'a, C, NC, A> UserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4133,7 +4129,7 @@ impl<'a, C, NC, A> UserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> UserGetCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> UserGetCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -4143,7 +4139,7 @@ impl<'a, C, NC, A> UserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// The ID of the user. - pub fn user_id(mut self, new_value: &str) -> UserGetCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserGetCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -4154,7 +4150,7 @@ impl<'a, C, NC, A> UserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4175,7 +4171,7 @@ impl<'a, C, NC, A> UserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4192,7 +4188,7 @@ impl<'a, C, NC, A> UserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4230,10 +4226,10 @@ impl<'a, C, NC, A> UserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct UserListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _email: String, _delegate: Option<&'a mut Delegate>, @@ -4241,9 +4237,9 @@ pub struct UserListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserListCall<'a, C, A> {} -impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4376,7 +4372,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> UserListCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> UserListCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -4386,7 +4382,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The exact primary email address of the user to look up. - pub fn email(mut self, new_value: &str) -> UserListCall<'a, C, NC, A> { + pub fn email(mut self, new_value: &str) -> UserListCall<'a, C, A> { self._email = new_value.to_string(); self } @@ -4397,7 +4393,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4418,7 +4414,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4435,7 +4431,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4473,10 +4469,10 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct UserGenerateTokenCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserGenerateTokenCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _user_id: String, _delegate: Option<&'a mut Delegate>, @@ -4484,9 +4480,9 @@ pub struct UserGenerateTokenCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserGenerateTokenCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserGenerateTokenCall<'a, C, A> {} -impl<'a, C, NC, A> UserGenerateTokenCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserGenerateTokenCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4619,7 +4615,7 @@ impl<'a, C, NC, A> UserGenerateTokenCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> UserGenerateTokenCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> UserGenerateTokenCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -4629,7 +4625,7 @@ impl<'a, C, NC, A> UserGenerateTokenCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the user. - pub fn user_id(mut self, new_value: &str) -> UserGenerateTokenCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserGenerateTokenCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -4640,7 +4636,7 @@ impl<'a, C, NC, A> UserGenerateTokenCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserGenerateTokenCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserGenerateTokenCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4661,7 +4657,7 @@ impl<'a, C, NC, A> UserGenerateTokenCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserGenerateTokenCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserGenerateTokenCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4678,7 +4674,7 @@ impl<'a, C, NC, A> UserGenerateTokenCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserGenerateTokenCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserGenerateTokenCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4722,10 +4718,10 @@ impl<'a, C, NC, A> UserGenerateTokenCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct InstallPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstallPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _request: Install, _enterprise_id: String, _user_id: String, @@ -4736,9 +4732,9 @@ pub struct InstallPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstallPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstallPatchCall<'a, C, A> {} -impl<'a, C, NC, A> InstallPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstallPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4880,7 +4876,7 @@ impl<'a, C, NC, A> InstallPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Install) -> InstallPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Install) -> InstallPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4890,7 +4886,7 @@ impl<'a, C, NC, A> InstallPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> InstallPatchCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> InstallPatchCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -4900,7 +4896,7 @@ impl<'a, C, NC, A> InstallPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the user. - pub fn user_id(mut self, new_value: &str) -> InstallPatchCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> InstallPatchCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -4910,7 +4906,7 @@ impl<'a, C, NC, A> InstallPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The Android ID of the device. - pub fn device_id(mut self, new_value: &str) -> InstallPatchCall<'a, C, NC, A> { + pub fn device_id(mut self, new_value: &str) -> InstallPatchCall<'a, C, A> { self._device_id = new_value.to_string(); self } @@ -4920,7 +4916,7 @@ impl<'a, C, NC, A> InstallPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the product represented by the install, e.g. "app:com.google.android.gm". - pub fn install_id(mut self, new_value: &str) -> InstallPatchCall<'a, C, NC, A> { + pub fn install_id(mut self, new_value: &str) -> InstallPatchCall<'a, C, A> { self._install_id = new_value.to_string(); self } @@ -4931,7 +4927,7 @@ impl<'a, C, NC, A> InstallPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstallPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstallPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4952,7 +4948,7 @@ impl<'a, C, NC, A> InstallPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstallPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstallPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4969,7 +4965,7 @@ impl<'a, C, NC, A> InstallPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstallPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstallPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5007,10 +5003,10 @@ impl<'a, C, NC, A> InstallPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct InstallGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstallGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _user_id: String, _device_id: String, @@ -5020,9 +5016,9 @@ pub struct InstallGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstallGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstallGetCall<'a, C, A> {} -impl<'a, C, NC, A> InstallGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstallGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5157,7 +5153,7 @@ impl<'a, C, NC, A> InstallGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> InstallGetCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> InstallGetCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -5167,7 +5163,7 @@ impl<'a, C, NC, A> InstallGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the user. - pub fn user_id(mut self, new_value: &str) -> InstallGetCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> InstallGetCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -5177,7 +5173,7 @@ impl<'a, C, NC, A> InstallGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The Android ID of the device. - pub fn device_id(mut self, new_value: &str) -> InstallGetCall<'a, C, NC, A> { + pub fn device_id(mut self, new_value: &str) -> InstallGetCall<'a, C, A> { self._device_id = new_value.to_string(); self } @@ -5187,7 +5183,7 @@ impl<'a, C, NC, A> InstallGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the product represented by the install, e.g. "app:com.google.android.gm". - pub fn install_id(mut self, new_value: &str) -> InstallGetCall<'a, C, NC, A> { + pub fn install_id(mut self, new_value: &str) -> InstallGetCall<'a, C, A> { self._install_id = new_value.to_string(); self } @@ -5198,7 +5194,7 @@ impl<'a, C, NC, A> InstallGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstallGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstallGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5219,7 +5215,7 @@ impl<'a, C, NC, A> InstallGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstallGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstallGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5236,7 +5232,7 @@ impl<'a, C, NC, A> InstallGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstallGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstallGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5274,10 +5270,10 @@ impl<'a, C, NC, A> InstallGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct InstallListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstallListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _user_id: String, _device_id: String, @@ -5286,9 +5282,9 @@ pub struct InstallListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstallListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstallListCall<'a, C, A> {} -impl<'a, C, NC, A> InstallListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstallListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5422,7 +5418,7 @@ impl<'a, C, NC, A> InstallListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> InstallListCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> InstallListCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -5432,7 +5428,7 @@ impl<'a, C, NC, A> InstallListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the user. - pub fn user_id(mut self, new_value: &str) -> InstallListCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> InstallListCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -5442,7 +5438,7 @@ impl<'a, C, NC, A> InstallListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The Android ID of the device. - pub fn device_id(mut self, new_value: &str) -> InstallListCall<'a, C, NC, A> { + pub fn device_id(mut self, new_value: &str) -> InstallListCall<'a, C, A> { self._device_id = new_value.to_string(); self } @@ -5453,7 +5449,7 @@ impl<'a, C, NC, A> InstallListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstallListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstallListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5474,7 +5470,7 @@ impl<'a, C, NC, A> InstallListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstallListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstallListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5491,7 +5487,7 @@ impl<'a, C, NC, A> InstallListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstallListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstallListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5529,10 +5525,10 @@ impl<'a, C, NC, A> InstallListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct InstallDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstallDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _user_id: String, _device_id: String, @@ -5542,9 +5538,9 @@ pub struct InstallDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstallDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstallDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> InstallDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstallDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5668,7 +5664,7 @@ impl<'a, C, NC, A> InstallDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> InstallDeleteCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> InstallDeleteCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -5678,7 +5674,7 @@ impl<'a, C, NC, A> InstallDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the user. - pub fn user_id(mut self, new_value: &str) -> InstallDeleteCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> InstallDeleteCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -5688,7 +5684,7 @@ impl<'a, C, NC, A> InstallDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The Android ID of the device. - pub fn device_id(mut self, new_value: &str) -> InstallDeleteCall<'a, C, NC, A> { + pub fn device_id(mut self, new_value: &str) -> InstallDeleteCall<'a, C, A> { self._device_id = new_value.to_string(); self } @@ -5698,7 +5694,7 @@ impl<'a, C, NC, A> InstallDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the product represented by the install, e.g. "app:com.google.android.gm". - pub fn install_id(mut self, new_value: &str) -> InstallDeleteCall<'a, C, NC, A> { + pub fn install_id(mut self, new_value: &str) -> InstallDeleteCall<'a, C, A> { self._install_id = new_value.to_string(); self } @@ -5709,7 +5705,7 @@ impl<'a, C, NC, A> InstallDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstallDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstallDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5730,7 +5726,7 @@ impl<'a, C, NC, A> InstallDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstallDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstallDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5747,7 +5743,7 @@ impl<'a, C, NC, A> InstallDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstallDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstallDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5791,10 +5787,10 @@ impl<'a, C, NC, A> InstallDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct InstallUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstallUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _request: Install, _enterprise_id: String, _user_id: String, @@ -5805,9 +5801,9 @@ pub struct InstallUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstallUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstallUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> InstallUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstallUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5949,7 +5945,7 @@ impl<'a, C, NC, A> InstallUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Install) -> InstallUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Install) -> InstallUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5959,7 +5955,7 @@ impl<'a, C, NC, A> InstallUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> InstallUpdateCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> InstallUpdateCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -5969,7 +5965,7 @@ impl<'a, C, NC, A> InstallUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the user. - pub fn user_id(mut self, new_value: &str) -> InstallUpdateCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> InstallUpdateCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -5979,7 +5975,7 @@ impl<'a, C, NC, A> InstallUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The Android ID of the device. - pub fn device_id(mut self, new_value: &str) -> InstallUpdateCall<'a, C, NC, A> { + pub fn device_id(mut self, new_value: &str) -> InstallUpdateCall<'a, C, A> { self._device_id = new_value.to_string(); self } @@ -5989,7 +5985,7 @@ impl<'a, C, NC, A> InstallUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the product represented by the install, e.g. "app:com.google.android.gm". - pub fn install_id(mut self, new_value: &str) -> InstallUpdateCall<'a, C, NC, A> { + pub fn install_id(mut self, new_value: &str) -> InstallUpdateCall<'a, C, A> { self._install_id = new_value.to_string(); self } @@ -6000,7 +5996,7 @@ impl<'a, C, NC, A> InstallUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstallUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstallUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6021,7 +6017,7 @@ impl<'a, C, NC, A> InstallUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstallUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstallUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6038,7 +6034,7 @@ impl<'a, C, NC, A> InstallUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstallUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstallUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6082,10 +6078,10 @@ impl<'a, C, NC, A> InstallUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct DeviceSetStateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DeviceSetStateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _request: DeviceState, _enterprise_id: String, _user_id: String, @@ -6095,9 +6091,9 @@ pub struct DeviceSetStateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DeviceSetStateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DeviceSetStateCall<'a, C, A> {} -impl<'a, C, NC, A> DeviceSetStateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DeviceSetStateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6238,7 +6234,7 @@ impl<'a, C, NC, A> DeviceSetStateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &DeviceState) -> DeviceSetStateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &DeviceState) -> DeviceSetStateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6248,7 +6244,7 @@ impl<'a, C, NC, A> DeviceSetStateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> DeviceSetStateCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> DeviceSetStateCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -6258,7 +6254,7 @@ impl<'a, C, NC, A> DeviceSetStateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the user. - pub fn user_id(mut self, new_value: &str) -> DeviceSetStateCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> DeviceSetStateCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -6268,7 +6264,7 @@ impl<'a, C, NC, A> DeviceSetStateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the device. - pub fn device_id(mut self, new_value: &str) -> DeviceSetStateCall<'a, C, NC, A> { + pub fn device_id(mut self, new_value: &str) -> DeviceSetStateCall<'a, C, A> { self._device_id = new_value.to_string(); self } @@ -6279,7 +6275,7 @@ impl<'a, C, NC, A> DeviceSetStateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeviceSetStateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeviceSetStateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6300,7 +6296,7 @@ impl<'a, C, NC, A> DeviceSetStateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DeviceSetStateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DeviceSetStateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6317,7 +6313,7 @@ impl<'a, C, NC, A> DeviceSetStateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DeviceSetStateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DeviceSetStateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6355,10 +6351,10 @@ impl<'a, C, NC, A> DeviceSetStateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct DeviceGetStateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DeviceGetStateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _user_id: String, _device_id: String, @@ -6367,9 +6363,9 @@ pub struct DeviceGetStateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DeviceGetStateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DeviceGetStateCall<'a, C, A> {} -impl<'a, C, NC, A> DeviceGetStateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DeviceGetStateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6503,7 +6499,7 @@ impl<'a, C, NC, A> DeviceGetStateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> DeviceGetStateCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> DeviceGetStateCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -6513,7 +6509,7 @@ impl<'a, C, NC, A> DeviceGetStateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the user. - pub fn user_id(mut self, new_value: &str) -> DeviceGetStateCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> DeviceGetStateCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -6523,7 +6519,7 @@ impl<'a, C, NC, A> DeviceGetStateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the device. - pub fn device_id(mut self, new_value: &str) -> DeviceGetStateCall<'a, C, NC, A> { + pub fn device_id(mut self, new_value: &str) -> DeviceGetStateCall<'a, C, A> { self._device_id = new_value.to_string(); self } @@ -6534,7 +6530,7 @@ impl<'a, C, NC, A> DeviceGetStateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeviceGetStateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeviceGetStateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6555,7 +6551,7 @@ impl<'a, C, NC, A> DeviceGetStateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DeviceGetStateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DeviceGetStateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6572,7 +6568,7 @@ impl<'a, C, NC, A> DeviceGetStateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DeviceGetStateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DeviceGetStateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6610,10 +6606,10 @@ impl<'a, C, NC, A> DeviceGetStateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct DeviceListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DeviceListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _user_id: String, _delegate: Option<&'a mut Delegate>, @@ -6621,9 +6617,9 @@ pub struct DeviceListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DeviceListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DeviceListCall<'a, C, A> {} -impl<'a, C, NC, A> DeviceListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DeviceListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6756,7 +6752,7 @@ impl<'a, C, NC, A> DeviceListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> DeviceListCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> DeviceListCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -6766,7 +6762,7 @@ impl<'a, C, NC, A> DeviceListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the user. - pub fn user_id(mut self, new_value: &str) -> DeviceListCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> DeviceListCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -6777,7 +6773,7 @@ impl<'a, C, NC, A> DeviceListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeviceListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeviceListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6798,7 +6794,7 @@ impl<'a, C, NC, A> DeviceListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DeviceListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DeviceListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6815,7 +6811,7 @@ impl<'a, C, NC, A> DeviceListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DeviceListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DeviceListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6853,10 +6849,10 @@ impl<'a, C, NC, A> DeviceListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct DeviceGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DeviceGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _user_id: String, _device_id: String, @@ -6865,9 +6861,9 @@ pub struct DeviceGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DeviceGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DeviceGetCall<'a, C, A> {} -impl<'a, C, NC, A> DeviceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DeviceGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7001,7 +6997,7 @@ impl<'a, C, NC, A> DeviceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> DeviceGetCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> DeviceGetCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -7011,7 +7007,7 @@ impl<'a, C, NC, A> DeviceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the user. - pub fn user_id(mut self, new_value: &str) -> DeviceGetCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> DeviceGetCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -7021,7 +7017,7 @@ impl<'a, C, NC, A> DeviceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the device. - pub fn device_id(mut self, new_value: &str) -> DeviceGetCall<'a, C, NC, A> { + pub fn device_id(mut self, new_value: &str) -> DeviceGetCall<'a, C, A> { self._device_id = new_value.to_string(); self } @@ -7032,7 +7028,7 @@ impl<'a, C, NC, A> DeviceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeviceGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeviceGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7053,7 +7049,7 @@ impl<'a, C, NC, A> DeviceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DeviceGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DeviceGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7070,7 +7066,7 @@ impl<'a, C, NC, A> DeviceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DeviceGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DeviceGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7108,19 +7104,19 @@ impl<'a, C, NC, A> DeviceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct EnterpriseUnenrollCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EnterpriseUnenrollCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EnterpriseUnenrollCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EnterpriseUnenrollCall<'a, C, A> {} -impl<'a, C, NC, A> EnterpriseUnenrollCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EnterpriseUnenrollCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7241,7 +7237,7 @@ impl<'a, C, NC, A> EnterpriseUnenrollCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> EnterpriseUnenrollCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> EnterpriseUnenrollCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -7252,7 +7248,7 @@ impl<'a, C, NC, A> EnterpriseUnenrollCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EnterpriseUnenrollCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EnterpriseUnenrollCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7273,7 +7269,7 @@ impl<'a, C, NC, A> EnterpriseUnenrollCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EnterpriseUnenrollCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EnterpriseUnenrollCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7290,7 +7286,7 @@ impl<'a, C, NC, A> EnterpriseUnenrollCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EnterpriseUnenrollCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EnterpriseUnenrollCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7334,10 +7330,10 @@ impl<'a, C, NC, A> EnterpriseUnenrollCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct EnterpriseInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EnterpriseInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _request: Enterprise, _token: String, _delegate: Option<&'a mut Delegate>, @@ -7345,9 +7341,9 @@ pub struct EnterpriseInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EnterpriseInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EnterpriseInsertCall<'a, C, A> {} -impl<'a, C, NC, A> EnterpriseInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EnterpriseInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7462,7 +7458,7 @@ impl<'a, C, NC, A> EnterpriseInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Enterprise) -> EnterpriseInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Enterprise) -> EnterpriseInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7472,7 +7468,7 @@ impl<'a, C, NC, A> EnterpriseInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The token provided by the enterprise to register the MDM. - pub fn token(mut self, new_value: &str) -> EnterpriseInsertCall<'a, C, NC, A> { + pub fn token(mut self, new_value: &str) -> EnterpriseInsertCall<'a, C, A> { self._token = new_value.to_string(); self } @@ -7483,7 +7479,7 @@ impl<'a, C, NC, A> EnterpriseInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EnterpriseInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EnterpriseInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7504,7 +7500,7 @@ impl<'a, C, NC, A> EnterpriseInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EnterpriseInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EnterpriseInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7521,7 +7517,7 @@ impl<'a, C, NC, A> EnterpriseInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EnterpriseInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EnterpriseInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7559,19 +7555,19 @@ impl<'a, C, NC, A> EnterpriseInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct EnterpriseListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EnterpriseListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _domain: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EnterpriseListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EnterpriseListCall<'a, C, A> {} -impl<'a, C, NC, A> EnterpriseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EnterpriseListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7679,7 +7675,7 @@ impl<'a, C, NC, A> EnterpriseListCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The exact primary domain name of the enterprise to look up. - pub fn domain(mut self, new_value: &str) -> EnterpriseListCall<'a, C, NC, A> { + pub fn domain(mut self, new_value: &str) -> EnterpriseListCall<'a, C, A> { self._domain = new_value.to_string(); self } @@ -7690,7 +7686,7 @@ impl<'a, C, NC, A> EnterpriseListCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EnterpriseListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EnterpriseListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7711,7 +7707,7 @@ impl<'a, C, NC, A> EnterpriseListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EnterpriseListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EnterpriseListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7728,7 +7724,7 @@ impl<'a, C, NC, A> EnterpriseListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EnterpriseListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EnterpriseListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7766,19 +7762,19 @@ impl<'a, C, NC, A> EnterpriseListCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct EnterpriseGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EnterpriseGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EnterpriseGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EnterpriseGetCall<'a, C, A> {} -impl<'a, C, NC, A> EnterpriseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EnterpriseGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7910,7 +7906,7 @@ impl<'a, C, NC, A> EnterpriseGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> EnterpriseGetCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> EnterpriseGetCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -7921,7 +7917,7 @@ impl<'a, C, NC, A> EnterpriseGetCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EnterpriseGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EnterpriseGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7942,7 +7938,7 @@ impl<'a, C, NC, A> EnterpriseGetCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EnterpriseGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EnterpriseGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7959,7 +7955,7 @@ impl<'a, C, NC, A> EnterpriseGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EnterpriseGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EnterpriseGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8003,10 +7999,10 @@ impl<'a, C, NC, A> EnterpriseGetCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct EnterpriseEnrollCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EnterpriseEnrollCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _request: Enterprise, _token: String, _delegate: Option<&'a mut Delegate>, @@ -8014,9 +8010,9 @@ pub struct EnterpriseEnrollCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EnterpriseEnrollCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EnterpriseEnrollCall<'a, C, A> {} -impl<'a, C, NC, A> EnterpriseEnrollCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EnterpriseEnrollCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8131,7 +8127,7 @@ impl<'a, C, NC, A> EnterpriseEnrollCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Enterprise) -> EnterpriseEnrollCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Enterprise) -> EnterpriseEnrollCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8141,7 +8137,7 @@ impl<'a, C, NC, A> EnterpriseEnrollCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The token provided by the enterprise to register the MDM. - pub fn token(mut self, new_value: &str) -> EnterpriseEnrollCall<'a, C, NC, A> { + pub fn token(mut self, new_value: &str) -> EnterpriseEnrollCall<'a, C, A> { self._token = new_value.to_string(); self } @@ -8152,7 +8148,7 @@ impl<'a, C, NC, A> EnterpriseEnrollCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EnterpriseEnrollCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EnterpriseEnrollCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8173,7 +8169,7 @@ impl<'a, C, NC, A> EnterpriseEnrollCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EnterpriseEnrollCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EnterpriseEnrollCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8190,7 +8186,7 @@ impl<'a, C, NC, A> EnterpriseEnrollCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EnterpriseEnrollCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EnterpriseEnrollCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8234,10 +8230,10 @@ impl<'a, C, NC, A> EnterpriseEnrollCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct EnterpriseSetAccountCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EnterpriseSetAccountCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _request: EnterpriseAccount, _enterprise_id: String, _delegate: Option<&'a mut Delegate>, @@ -8245,9 +8241,9 @@ pub struct EnterpriseSetAccountCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EnterpriseSetAccountCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EnterpriseSetAccountCall<'a, C, A> {} -impl<'a, C, NC, A> EnterpriseSetAccountCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EnterpriseSetAccountCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8386,7 +8382,7 @@ impl<'a, C, NC, A> EnterpriseSetAccountCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &EnterpriseAccount) -> EnterpriseSetAccountCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &EnterpriseAccount) -> EnterpriseSetAccountCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8396,7 +8392,7 @@ impl<'a, C, NC, A> EnterpriseSetAccountCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> EnterpriseSetAccountCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> EnterpriseSetAccountCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -8407,7 +8403,7 @@ impl<'a, C, NC, A> EnterpriseSetAccountCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EnterpriseSetAccountCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EnterpriseSetAccountCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8428,7 +8424,7 @@ impl<'a, C, NC, A> EnterpriseSetAccountCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EnterpriseSetAccountCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EnterpriseSetAccountCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8445,7 +8441,7 @@ impl<'a, C, NC, A> EnterpriseSetAccountCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EnterpriseSetAccountCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EnterpriseSetAccountCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8483,19 +8479,19 @@ impl<'a, C, NC, A> EnterpriseSetAccountCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct EnterpriseDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EnterpriseDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EnterpriseDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EnterpriseDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> EnterpriseDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EnterpriseDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8616,7 +8612,7 @@ impl<'a, C, NC, A> EnterpriseDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> EnterpriseDeleteCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> EnterpriseDeleteCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -8627,7 +8623,7 @@ impl<'a, C, NC, A> EnterpriseDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EnterpriseDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EnterpriseDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8648,7 +8644,7 @@ impl<'a, C, NC, A> EnterpriseDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EnterpriseDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EnterpriseDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8665,7 +8661,7 @@ impl<'a, C, NC, A> EnterpriseDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EnterpriseDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EnterpriseDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8709,10 +8705,10 @@ impl<'a, C, NC, A> EnterpriseDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct CollectionInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CollectionInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _request: Collection, _enterprise_id: String, _delegate: Option<&'a mut Delegate>, @@ -8720,9 +8716,9 @@ pub struct CollectionInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CollectionInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CollectionInsertCall<'a, C, A> {} -impl<'a, C, NC, A> CollectionInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CollectionInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8861,7 +8857,7 @@ impl<'a, C, NC, A> CollectionInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Collection) -> CollectionInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Collection) -> CollectionInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8871,7 +8867,7 @@ impl<'a, C, NC, A> CollectionInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> CollectionInsertCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> CollectionInsertCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -8882,7 +8878,7 @@ impl<'a, C, NC, A> CollectionInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CollectionInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CollectionInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8903,7 +8899,7 @@ impl<'a, C, NC, A> CollectionInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CollectionInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CollectionInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8920,7 +8916,7 @@ impl<'a, C, NC, A> CollectionInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CollectionInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CollectionInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8964,10 +8960,10 @@ impl<'a, C, NC, A> CollectionInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct CollectionPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CollectionPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _request: Collection, _enterprise_id: String, _collection_id: String, @@ -8976,9 +8972,9 @@ pub struct CollectionPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CollectionPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CollectionPatchCall<'a, C, A> {} -impl<'a, C, NC, A> CollectionPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CollectionPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9118,7 +9114,7 @@ impl<'a, C, NC, A> CollectionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Collection) -> CollectionPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Collection) -> CollectionPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9128,7 +9124,7 @@ impl<'a, C, NC, A> CollectionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> CollectionPatchCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> CollectionPatchCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -9138,7 +9134,7 @@ impl<'a, C, NC, A> CollectionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the collection. - pub fn collection_id(mut self, new_value: &str) -> CollectionPatchCall<'a, C, NC, A> { + pub fn collection_id(mut self, new_value: &str) -> CollectionPatchCall<'a, C, A> { self._collection_id = new_value.to_string(); self } @@ -9149,7 +9145,7 @@ impl<'a, C, NC, A> CollectionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CollectionPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CollectionPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9170,7 +9166,7 @@ impl<'a, C, NC, A> CollectionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CollectionPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CollectionPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9187,7 +9183,7 @@ impl<'a, C, NC, A> CollectionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CollectionPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CollectionPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9231,10 +9227,10 @@ impl<'a, C, NC, A> CollectionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct CollectionUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CollectionUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _request: Collection, _enterprise_id: String, _collection_id: String, @@ -9243,9 +9239,9 @@ pub struct CollectionUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CollectionUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CollectionUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> CollectionUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CollectionUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9385,7 +9381,7 @@ impl<'a, C, NC, A> CollectionUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Collection) -> CollectionUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Collection) -> CollectionUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9395,7 +9391,7 @@ impl<'a, C, NC, A> CollectionUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> CollectionUpdateCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> CollectionUpdateCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -9405,7 +9401,7 @@ impl<'a, C, NC, A> CollectionUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID of the collection. - pub fn collection_id(mut self, new_value: &str) -> CollectionUpdateCall<'a, C, NC, A> { + pub fn collection_id(mut self, new_value: &str) -> CollectionUpdateCall<'a, C, A> { self._collection_id = new_value.to_string(); self } @@ -9416,7 +9412,7 @@ impl<'a, C, NC, A> CollectionUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CollectionUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CollectionUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9437,7 +9433,7 @@ impl<'a, C, NC, A> CollectionUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CollectionUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CollectionUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9454,7 +9450,7 @@ impl<'a, C, NC, A> CollectionUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CollectionUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CollectionUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9492,19 +9488,19 @@ impl<'a, C, NC, A> CollectionUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct CollectionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CollectionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CollectionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CollectionListCall<'a, C, A> {} -impl<'a, C, NC, A> CollectionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CollectionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9636,7 +9632,7 @@ impl<'a, C, NC, A> CollectionListCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> CollectionListCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> CollectionListCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -9647,7 +9643,7 @@ impl<'a, C, NC, A> CollectionListCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CollectionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CollectionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9668,7 +9664,7 @@ impl<'a, C, NC, A> CollectionListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CollectionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CollectionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9685,7 +9681,7 @@ impl<'a, C, NC, A> CollectionListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CollectionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CollectionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9723,10 +9719,10 @@ impl<'a, C, NC, A> CollectionListCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct CollectionGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CollectionGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _collection_id: String, _delegate: Option<&'a mut Delegate>, @@ -9734,9 +9730,9 @@ pub struct CollectionGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CollectionGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CollectionGetCall<'a, C, A> {} -impl<'a, C, NC, A> CollectionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CollectionGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9869,7 +9865,7 @@ impl<'a, C, NC, A> CollectionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> CollectionGetCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> CollectionGetCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -9879,7 +9875,7 @@ impl<'a, C, NC, A> CollectionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the collection. - pub fn collection_id(mut self, new_value: &str) -> CollectionGetCall<'a, C, NC, A> { + pub fn collection_id(mut self, new_value: &str) -> CollectionGetCall<'a, C, A> { self._collection_id = new_value.to_string(); self } @@ -9890,7 +9886,7 @@ impl<'a, C, NC, A> CollectionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CollectionGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CollectionGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9911,7 +9907,7 @@ impl<'a, C, NC, A> CollectionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CollectionGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CollectionGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9928,7 +9924,7 @@ impl<'a, C, NC, A> CollectionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CollectionGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CollectionGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9966,10 +9962,10 @@ impl<'a, C, NC, A> CollectionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct CollectionDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CollectionDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _collection_id: String, _delegate: Option<&'a mut Delegate>, @@ -9977,9 +9973,9 @@ pub struct CollectionDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CollectionDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CollectionDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> CollectionDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CollectionDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10101,7 +10097,7 @@ impl<'a, C, NC, A> CollectionDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> CollectionDeleteCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> CollectionDeleteCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -10111,7 +10107,7 @@ impl<'a, C, NC, A> CollectionDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID of the collection. - pub fn collection_id(mut self, new_value: &str) -> CollectionDeleteCall<'a, C, NC, A> { + pub fn collection_id(mut self, new_value: &str) -> CollectionDeleteCall<'a, C, A> { self._collection_id = new_value.to_string(); self } @@ -10122,7 +10118,7 @@ impl<'a, C, NC, A> CollectionDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CollectionDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CollectionDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10143,7 +10139,7 @@ impl<'a, C, NC, A> CollectionDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CollectionDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CollectionDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10160,7 +10156,7 @@ impl<'a, C, NC, A> CollectionDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CollectionDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CollectionDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10198,10 +10194,10 @@ impl<'a, C, NC, A> CollectionDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct GrouplicenseuserListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GrouplicenseuserListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _group_license_id: String, _delegate: Option<&'a mut Delegate>, @@ -10209,9 +10205,9 @@ pub struct GrouplicenseuserListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GrouplicenseuserListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GrouplicenseuserListCall<'a, C, A> {} -impl<'a, C, NC, A> GrouplicenseuserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GrouplicenseuserListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10344,7 +10340,7 @@ impl<'a, C, NC, A> GrouplicenseuserListCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> GrouplicenseuserListCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> GrouplicenseuserListCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -10354,7 +10350,7 @@ impl<'a, C, NC, A> GrouplicenseuserListCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The ID of the product the group license is for, e.g. "app:com.google.android.gm". - pub fn group_license_id(mut self, new_value: &str) -> GrouplicenseuserListCall<'a, C, NC, A> { + pub fn group_license_id(mut self, new_value: &str) -> GrouplicenseuserListCall<'a, C, A> { self._group_license_id = new_value.to_string(); self } @@ -10365,7 +10361,7 @@ impl<'a, C, NC, A> GrouplicenseuserListCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GrouplicenseuserListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GrouplicenseuserListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10386,7 +10382,7 @@ impl<'a, C, NC, A> GrouplicenseuserListCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GrouplicenseuserListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GrouplicenseuserListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10403,7 +10399,7 @@ impl<'a, C, NC, A> GrouplicenseuserListCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GrouplicenseuserListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GrouplicenseuserListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10448,10 +10444,10 @@ impl<'a, C, NC, A> GrouplicenseuserListCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct EntitlementUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EntitlementUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _request: Entitlement, _enterprise_id: String, _user_id: String, @@ -10462,9 +10458,9 @@ pub struct EntitlementUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EntitlementUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EntitlementUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> EntitlementUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EntitlementUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10608,7 +10604,7 @@ impl<'a, C, NC, A> EntitlementUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Entitlement) -> EntitlementUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Entitlement) -> EntitlementUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -10618,7 +10614,7 @@ impl<'a, C, NC, A> EntitlementUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> EntitlementUpdateCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> EntitlementUpdateCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -10628,7 +10624,7 @@ impl<'a, C, NC, A> EntitlementUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the user. - pub fn user_id(mut self, new_value: &str) -> EntitlementUpdateCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> EntitlementUpdateCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -10638,7 +10634,7 @@ impl<'a, C, NC, A> EntitlementUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the entitlement, e.g. "app:com.google.android.gm". - pub fn entitlement_id(mut self, new_value: &str) -> EntitlementUpdateCall<'a, C, NC, A> { + pub fn entitlement_id(mut self, new_value: &str) -> EntitlementUpdateCall<'a, C, A> { self._entitlement_id = new_value.to_string(); self } @@ -10646,7 +10642,7 @@ impl<'a, C, NC, A> EntitlementUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Set to true to also install the product on all the user's devices where possible. Failure to install on one or more devices will not prevent this operation from returning successfully, as long as the entitlement was successfully assigned to the user. - pub fn install(mut self, new_value: bool) -> EntitlementUpdateCall<'a, C, NC, A> { + pub fn install(mut self, new_value: bool) -> EntitlementUpdateCall<'a, C, A> { self._install = Some(new_value); self } @@ -10657,7 +10653,7 @@ impl<'a, C, NC, A> EntitlementUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EntitlementUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EntitlementUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10678,7 +10674,7 @@ impl<'a, C, NC, A> EntitlementUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EntitlementUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EntitlementUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10695,7 +10691,7 @@ impl<'a, C, NC, A> EntitlementUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EntitlementUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EntitlementUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10733,10 +10729,10 @@ impl<'a, C, NC, A> EntitlementUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct EntitlementListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EntitlementListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _user_id: String, _delegate: Option<&'a mut Delegate>, @@ -10744,9 +10740,9 @@ pub struct EntitlementListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EntitlementListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EntitlementListCall<'a, C, A> {} -impl<'a, C, NC, A> EntitlementListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EntitlementListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10879,7 +10875,7 @@ impl<'a, C, NC, A> EntitlementListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> EntitlementListCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> EntitlementListCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -10889,7 +10885,7 @@ impl<'a, C, NC, A> EntitlementListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the user. - pub fn user_id(mut self, new_value: &str) -> EntitlementListCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> EntitlementListCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -10900,7 +10896,7 @@ impl<'a, C, NC, A> EntitlementListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EntitlementListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EntitlementListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10921,7 +10917,7 @@ impl<'a, C, NC, A> EntitlementListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EntitlementListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EntitlementListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10938,7 +10934,7 @@ impl<'a, C, NC, A> EntitlementListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EntitlementListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EntitlementListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10976,10 +10972,10 @@ impl<'a, C, NC, A> EntitlementListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct EntitlementGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EntitlementGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _user_id: String, _entitlement_id: String, @@ -10988,9 +10984,9 @@ pub struct EntitlementGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EntitlementGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EntitlementGetCall<'a, C, A> {} -impl<'a, C, NC, A> EntitlementGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EntitlementGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11124,7 +11120,7 @@ impl<'a, C, NC, A> EntitlementGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> EntitlementGetCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> EntitlementGetCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -11134,7 +11130,7 @@ impl<'a, C, NC, A> EntitlementGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the user. - pub fn user_id(mut self, new_value: &str) -> EntitlementGetCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> EntitlementGetCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -11144,7 +11140,7 @@ impl<'a, C, NC, A> EntitlementGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the entitlement, e.g. "app:com.google.android.gm". - pub fn entitlement_id(mut self, new_value: &str) -> EntitlementGetCall<'a, C, NC, A> { + pub fn entitlement_id(mut self, new_value: &str) -> EntitlementGetCall<'a, C, A> { self._entitlement_id = new_value.to_string(); self } @@ -11155,7 +11151,7 @@ impl<'a, C, NC, A> EntitlementGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EntitlementGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EntitlementGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11176,7 +11172,7 @@ impl<'a, C, NC, A> EntitlementGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EntitlementGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EntitlementGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11193,7 +11189,7 @@ impl<'a, C, NC, A> EntitlementGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EntitlementGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EntitlementGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11238,10 +11234,10 @@ impl<'a, C, NC, A> EntitlementGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct EntitlementPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EntitlementPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _request: Entitlement, _enterprise_id: String, _user_id: String, @@ -11252,9 +11248,9 @@ pub struct EntitlementPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EntitlementPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EntitlementPatchCall<'a, C, A> {} -impl<'a, C, NC, A> EntitlementPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EntitlementPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11398,7 +11394,7 @@ impl<'a, C, NC, A> EntitlementPatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Entitlement) -> EntitlementPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Entitlement) -> EntitlementPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -11408,7 +11404,7 @@ impl<'a, C, NC, A> EntitlementPatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> EntitlementPatchCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> EntitlementPatchCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -11418,7 +11414,7 @@ impl<'a, C, NC, A> EntitlementPatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID of the user. - pub fn user_id(mut self, new_value: &str) -> EntitlementPatchCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> EntitlementPatchCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -11428,7 +11424,7 @@ impl<'a, C, NC, A> EntitlementPatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID of the entitlement, e.g. "app:com.google.android.gm". - pub fn entitlement_id(mut self, new_value: &str) -> EntitlementPatchCall<'a, C, NC, A> { + pub fn entitlement_id(mut self, new_value: &str) -> EntitlementPatchCall<'a, C, A> { self._entitlement_id = new_value.to_string(); self } @@ -11436,7 +11432,7 @@ impl<'a, C, NC, A> EntitlementPatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Set to true to also install the product on all the user's devices where possible. Failure to install on one or more devices will not prevent this operation from returning successfully, as long as the entitlement was successfully assigned to the user. - pub fn install(mut self, new_value: bool) -> EntitlementPatchCall<'a, C, NC, A> { + pub fn install(mut self, new_value: bool) -> EntitlementPatchCall<'a, C, A> { self._install = Some(new_value); self } @@ -11447,7 +11443,7 @@ impl<'a, C, NC, A> EntitlementPatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EntitlementPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EntitlementPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11468,7 +11464,7 @@ impl<'a, C, NC, A> EntitlementPatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EntitlementPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EntitlementPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11485,7 +11481,7 @@ impl<'a, C, NC, A> EntitlementPatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EntitlementPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EntitlementPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11523,10 +11519,10 @@ impl<'a, C, NC, A> EntitlementPatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct EntitlementDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EntitlementDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _user_id: String, _entitlement_id: String, @@ -11535,9 +11531,9 @@ pub struct EntitlementDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EntitlementDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EntitlementDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> EntitlementDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EntitlementDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11660,7 +11656,7 @@ impl<'a, C, NC, A> EntitlementDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> EntitlementDeleteCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> EntitlementDeleteCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -11670,7 +11666,7 @@ impl<'a, C, NC, A> EntitlementDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the user. - pub fn user_id(mut self, new_value: &str) -> EntitlementDeleteCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> EntitlementDeleteCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -11680,7 +11676,7 @@ impl<'a, C, NC, A> EntitlementDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the entitlement, e.g. "app:com.google.android.gm". - pub fn entitlement_id(mut self, new_value: &str) -> EntitlementDeleteCall<'a, C, NC, A> { + pub fn entitlement_id(mut self, new_value: &str) -> EntitlementDeleteCall<'a, C, A> { self._entitlement_id = new_value.to_string(); self } @@ -11691,7 +11687,7 @@ impl<'a, C, NC, A> EntitlementDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EntitlementDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EntitlementDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11712,7 +11708,7 @@ impl<'a, C, NC, A> EntitlementDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EntitlementDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EntitlementDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11729,7 +11725,7 @@ impl<'a, C, NC, A> EntitlementDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EntitlementDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EntitlementDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11767,10 +11763,10 @@ impl<'a, C, NC, A> EntitlementDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct ProductGetPermissionCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProductGetPermissionCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _product_id: String, _delegate: Option<&'a mut Delegate>, @@ -11778,9 +11774,9 @@ pub struct ProductGetPermissionCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProductGetPermissionCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProductGetPermissionCall<'a, C, A> {} -impl<'a, C, NC, A> ProductGetPermissionCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProductGetPermissionCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11913,7 +11909,7 @@ impl<'a, C, NC, A> ProductGetPermissionCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> ProductGetPermissionCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> ProductGetPermissionCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -11923,7 +11919,7 @@ impl<'a, C, NC, A> ProductGetPermissionCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The ID of the product. - pub fn product_id(mut self, new_value: &str) -> ProductGetPermissionCall<'a, C, NC, A> { + pub fn product_id(mut self, new_value: &str) -> ProductGetPermissionCall<'a, C, A> { self._product_id = new_value.to_string(); self } @@ -11934,7 +11930,7 @@ impl<'a, C, NC, A> ProductGetPermissionCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductGetPermissionCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductGetPermissionCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11955,7 +11951,7 @@ impl<'a, C, NC, A> ProductGetPermissionCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProductGetPermissionCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProductGetPermissionCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11972,7 +11968,7 @@ impl<'a, C, NC, A> ProductGetPermissionCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProductGetPermissionCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProductGetPermissionCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12011,10 +12007,10 @@ impl<'a, C, NC, A> ProductGetPermissionCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct ProductGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProductGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _product_id: String, _language: Option, @@ -12023,9 +12019,9 @@ pub struct ProductGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProductGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProductGetCall<'a, C, A> {} -impl<'a, C, NC, A> ProductGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProductGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12161,7 +12157,7 @@ impl<'a, C, NC, A> ProductGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> ProductGetCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> ProductGetCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -12171,7 +12167,7 @@ impl<'a, C, NC, A> ProductGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the product, e.g. "app:com.google.android.gm". - pub fn product_id(mut self, new_value: &str) -> ProductGetCall<'a, C, NC, A> { + pub fn product_id(mut self, new_value: &str) -> ProductGetCall<'a, C, A> { self._product_id = new_value.to_string(); self } @@ -12179,7 +12175,7 @@ impl<'a, C, NC, A> ProductGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The BCP47 tag for the user's preferred language (e.g. "en-US", "de"). - pub fn language(mut self, new_value: &str) -> ProductGetCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> ProductGetCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -12190,7 +12186,7 @@ impl<'a, C, NC, A> ProductGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12211,7 +12207,7 @@ impl<'a, C, NC, A> ProductGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProductGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProductGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12228,7 +12224,7 @@ impl<'a, C, NC, A> ProductGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProductGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProductGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12267,10 +12263,10 @@ impl<'a, C, NC, A> ProductGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct ProductGetAppRestrictionsSchemaCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProductGetAppRestrictionsSchemaCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _product_id: String, _language: Option, @@ -12279,9 +12275,9 @@ pub struct ProductGetAppRestrictionsSchemaCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProductGetAppRestrictionsSchemaCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProductGetAppRestrictionsSchemaCall<'a, C, A> {} -impl<'a, C, NC, A> ProductGetAppRestrictionsSchemaCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProductGetAppRestrictionsSchemaCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12417,7 +12413,7 @@ impl<'a, C, NC, A> ProductGetAppRestrictionsSchemaCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> ProductGetAppRestrictionsSchemaCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> ProductGetAppRestrictionsSchemaCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -12427,7 +12423,7 @@ impl<'a, C, NC, A> ProductGetAppRestrictionsSchemaCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// The ID of the product. - pub fn product_id(mut self, new_value: &str) -> ProductGetAppRestrictionsSchemaCall<'a, C, NC, A> { + pub fn product_id(mut self, new_value: &str) -> ProductGetAppRestrictionsSchemaCall<'a, C, A> { self._product_id = new_value.to_string(); self } @@ -12435,7 +12431,7 @@ impl<'a, C, NC, A> ProductGetAppRestrictionsSchemaCall<'a, C, NC, A> where NC: h /// /// /// The BCP47 tag for the user's preferred language (e.g. "en-US", "de"). - pub fn language(mut self, new_value: &str) -> ProductGetAppRestrictionsSchemaCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> ProductGetAppRestrictionsSchemaCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -12446,7 +12442,7 @@ impl<'a, C, NC, A> ProductGetAppRestrictionsSchemaCall<'a, C, NC, A> where NC: h /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductGetAppRestrictionsSchemaCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductGetAppRestrictionsSchemaCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12467,7 +12463,7 @@ impl<'a, C, NC, A> ProductGetAppRestrictionsSchemaCall<'a, C, NC, A> where NC: h /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProductGetAppRestrictionsSchemaCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProductGetAppRestrictionsSchemaCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12484,7 +12480,7 @@ impl<'a, C, NC, A> ProductGetAppRestrictionsSchemaCall<'a, C, NC, A> where NC: h /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProductGetAppRestrictionsSchemaCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProductGetAppRestrictionsSchemaCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12528,10 +12524,10 @@ impl<'a, C, NC, A> ProductGetAppRestrictionsSchemaCall<'a, C, NC, A> where NC: h /// .doit(); /// # } /// ``` -pub struct ProductUpdatePermissionCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProductUpdatePermissionCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _request: ProductPermissions, _enterprise_id: String, _product_id: String, @@ -12540,9 +12536,9 @@ pub struct ProductUpdatePermissionCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProductUpdatePermissionCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProductUpdatePermissionCall<'a, C, A> {} -impl<'a, C, NC, A> ProductUpdatePermissionCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProductUpdatePermissionCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12682,7 +12678,7 @@ impl<'a, C, NC, A> ProductUpdatePermissionCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ProductPermissions) -> ProductUpdatePermissionCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ProductPermissions) -> ProductUpdatePermissionCall<'a, C, A> { self._request = new_value.clone(); self } @@ -12692,7 +12688,7 @@ impl<'a, C, NC, A> ProductUpdatePermissionCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> ProductUpdatePermissionCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> ProductUpdatePermissionCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -12702,7 +12698,7 @@ impl<'a, C, NC, A> ProductUpdatePermissionCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The ID of the product. - pub fn product_id(mut self, new_value: &str) -> ProductUpdatePermissionCall<'a, C, NC, A> { + pub fn product_id(mut self, new_value: &str) -> ProductUpdatePermissionCall<'a, C, A> { self._product_id = new_value.to_string(); self } @@ -12713,7 +12709,7 @@ impl<'a, C, NC, A> ProductUpdatePermissionCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductUpdatePermissionCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductUpdatePermissionCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12734,7 +12730,7 @@ impl<'a, C, NC, A> ProductUpdatePermissionCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProductUpdatePermissionCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProductUpdatePermissionCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12751,7 +12747,7 @@ impl<'a, C, NC, A> ProductUpdatePermissionCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProductUpdatePermissionCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProductUpdatePermissionCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12789,10 +12785,10 @@ impl<'a, C, NC, A> ProductUpdatePermissionCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct GrouplicenseGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GrouplicenseGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _group_license_id: String, _delegate: Option<&'a mut Delegate>, @@ -12800,9 +12796,9 @@ pub struct GrouplicenseGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GrouplicenseGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GrouplicenseGetCall<'a, C, A> {} -impl<'a, C, NC, A> GrouplicenseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GrouplicenseGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12935,7 +12931,7 @@ impl<'a, C, NC, A> GrouplicenseGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> GrouplicenseGetCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> GrouplicenseGetCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -12945,7 +12941,7 @@ impl<'a, C, NC, A> GrouplicenseGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the product the group license is for, e.g. "app:com.google.android.gm". - pub fn group_license_id(mut self, new_value: &str) -> GrouplicenseGetCall<'a, C, NC, A> { + pub fn group_license_id(mut self, new_value: &str) -> GrouplicenseGetCall<'a, C, A> { self._group_license_id = new_value.to_string(); self } @@ -12956,7 +12952,7 @@ impl<'a, C, NC, A> GrouplicenseGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GrouplicenseGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GrouplicenseGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12977,7 +12973,7 @@ impl<'a, C, NC, A> GrouplicenseGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GrouplicenseGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GrouplicenseGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12994,7 +12990,7 @@ impl<'a, C, NC, A> GrouplicenseGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GrouplicenseGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GrouplicenseGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13032,19 +13028,19 @@ impl<'a, C, NC, A> GrouplicenseGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct GrouplicenseListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GrouplicenseListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _enterprise_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GrouplicenseListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GrouplicenseListCall<'a, C, A> {} -impl<'a, C, NC, A> GrouplicenseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GrouplicenseListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13176,7 +13172,7 @@ impl<'a, C, NC, A> GrouplicenseListCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID of the enterprise. - pub fn enterprise_id(mut self, new_value: &str) -> GrouplicenseListCall<'a, C, NC, A> { + pub fn enterprise_id(mut self, new_value: &str) -> GrouplicenseListCall<'a, C, A> { self._enterprise_id = new_value.to_string(); self } @@ -13187,7 +13183,7 @@ impl<'a, C, NC, A> GrouplicenseListCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GrouplicenseListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GrouplicenseListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13208,7 +13204,7 @@ impl<'a, C, NC, A> GrouplicenseListCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GrouplicenseListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GrouplicenseListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13225,7 +13221,7 @@ impl<'a, C, NC, A> GrouplicenseListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GrouplicenseListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GrouplicenseListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13264,10 +13260,10 @@ impl<'a, C, NC, A> GrouplicenseListCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct PermissionGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PermissionGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidEnterprise, + hub: &'a AndroidEnterprise, _permission_id: String, _language: Option, _delegate: Option<&'a mut Delegate>, @@ -13275,9 +13271,9 @@ pub struct PermissionGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PermissionGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PermissionGetCall<'a, C, A> {} -impl<'a, C, NC, A> PermissionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PermissionGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13412,7 +13408,7 @@ impl<'a, C, NC, A> PermissionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the permission. - pub fn permission_id(mut self, new_value: &str) -> PermissionGetCall<'a, C, NC, A> { + pub fn permission_id(mut self, new_value: &str) -> PermissionGetCall<'a, C, A> { self._permission_id = new_value.to_string(); self } @@ -13420,7 +13416,7 @@ impl<'a, C, NC, A> PermissionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// The BCP47 tag for the user's preferred language (e.g. "en-US", "de") - pub fn language(mut self, new_value: &str) -> PermissionGetCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> PermissionGetCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -13431,7 +13427,7 @@ impl<'a, C, NC, A> PermissionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PermissionGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PermissionGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13452,7 +13448,7 @@ impl<'a, C, NC, A> PermissionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PermissionGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PermissionGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13469,7 +13465,7 @@ impl<'a, C, NC, A> PermissionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PermissionGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PermissionGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/androidpublisher2/Cargo.toml b/gen/androidpublisher2/Cargo.toml index a59edcaf452..77445b73a9b 100644 --- a/gen/androidpublisher2/Cargo.toml +++ b/gen/androidpublisher2/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-androidpublisher2" -version = "0.1.4+20150323" +version = "0.1.5+20150323" authors = ["Sebastian Thiel "] description = "A complete library to interact with Android Publisher (protocol v2)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/androidpublisher2" homepage = "https://developers.google.com/android-publisher" -documentation = "http://byron.github.io/google-apis-rs/google-androidpublisher2" +documentation = "http://byron.github.io/google-apis-rs/google_androidpublisher2" license = "MIT" keywords = ["androidpublisher", "google", "protocol", "web", "api"] diff --git a/gen/androidpublisher2/README.md b/gen/androidpublisher2/README.md index 6c540303600..b59d301e13a 100644 --- a/gen/androidpublisher2/README.md +++ b/gen/androidpublisher2/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-androidpublisher2` library allows access to all features of the *Google Android Publisher* service. -This documentation was generated from *Android Publisher* crate version *0.1.4+20150323*, where *20150323* is the exact revision of the *androidpublisher:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *Android Publisher* crate version *0.1.5+20150323*, where *20150323* is the exact revision of the *androidpublisher:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *Android Publisher* *v2* API can be found at the [official documentation site](https://developers.google.com/android-publisher). diff --git a/gen/androidpublisher2/src/cmn.rs b/gen/androidpublisher2/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/androidpublisher2/src/cmn.rs +++ b/gen/androidpublisher2/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/androidpublisher2/src/lib.rs b/gen/androidpublisher2/src/lib.rs index 7f85292cbd7..893dbbcdcf1 100644 --- a/gen/androidpublisher2/src/lib.rs +++ b/gen/androidpublisher2/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *Android Publisher* crate version *0.1.4+20150323*, where *20150323* is the exact revision of the *androidpublisher:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *Android Publisher* crate version *0.1.5+20150323*, where *20150323* is the exact revision of the *androidpublisher:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *Android Publisher* *v2* API can be found at the //! [official documentation site](https://developers.google.com/android-publisher). @@ -208,7 +208,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -306,40 +305,37 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct AndroidPublisher { +pub struct AndroidPublisher { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for AndroidPublisher {} +impl<'a, C, A> Hub for AndroidPublisher {} -impl<'a, C, NC, A> AndroidPublisher - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AndroidPublisher + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> AndroidPublisher { + pub fn new(client: C, authenticator: A) -> AndroidPublisher { AndroidPublisher { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn edits(&'a self) -> EditMethods<'a, C, NC, A> { + pub fn edits(&'a self) -> EditMethods<'a, C, A> { EditMethods { hub: &self } } - pub fn inappproducts(&'a self) -> InappproductMethods<'a, C, NC, A> { + pub fn inappproducts(&'a self) -> InappproductMethods<'a, C, A> { InappproductMethods { hub: &self } } - pub fn purchases(&'a self) -> PurchaseMethods<'a, C, NC, A> { + pub fn purchases(&'a self) -> PurchaseMethods<'a, C, A> { PurchaseMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -1306,15 +1302,15 @@ impl ResponseResult for ListingsListResponse {} /// let rb = hub.purchases(); /// # } /// ``` -pub struct PurchaseMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PurchaseMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, } -impl<'a, C, NC, A> MethodsBuilder for PurchaseMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PurchaseMethods<'a, C, A> {} -impl<'a, C, NC, A> PurchaseMethods<'a, C, NC, A> { +impl<'a, C, A> PurchaseMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1325,7 +1321,7 @@ impl<'a, C, NC, A> PurchaseMethods<'a, C, NC, A> { /// * `packageName` - The package name of the application for which this subscription was purchased (for example, 'com.some.thing'). /// * `subscriptionId` - The purchased subscription ID (for example, 'monthly001'). /// * `token` - The token provided to the user's device when the subscription was purchased. - pub fn subscriptions_revoke(&self, package_name: &str, subscription_id: &str, token: &str) -> PurchaseSubscriptionRevokeCall<'a, C, NC, A> { + pub fn subscriptions_revoke(&self, package_name: &str, subscription_id: &str, token: &str) -> PurchaseSubscriptionRevokeCall<'a, C, A> { PurchaseSubscriptionRevokeCall { hub: self.hub, _package_name: package_name.to_string(), @@ -1346,7 +1342,7 @@ impl<'a, C, NC, A> PurchaseMethods<'a, C, NC, A> { /// * `packageName` - The package name of the application the inapp product was sold in (for example, 'com.some.thing'). /// * `productId` - The inapp product SKU (for example, 'com.some.thing.inapp1'). /// * `token` - The token provided to the user's device when the inapp product was purchased. - pub fn products_get(&self, package_name: &str, product_id: &str, token: &str) -> PurchaseProductGetCall<'a, C, NC, A> { + pub fn products_get(&self, package_name: &str, product_id: &str, token: &str) -> PurchaseProductGetCall<'a, C, A> { PurchaseProductGetCall { hub: self.hub, _package_name: package_name.to_string(), @@ -1367,7 +1363,7 @@ impl<'a, C, NC, A> PurchaseMethods<'a, C, NC, A> { /// * `packageName` - The package name of the application for which this subscription was purchased (for example, 'com.some.thing'). /// * `subscriptionId` - The purchased subscription ID (for example, 'monthly001'). /// * `token` - The token provided to the user's device when the subscription was purchased. - pub fn subscriptions_get(&self, package_name: &str, subscription_id: &str, token: &str) -> PurchaseSubscriptionGetCall<'a, C, NC, A> { + pub fn subscriptions_get(&self, package_name: &str, subscription_id: &str, token: &str) -> PurchaseSubscriptionGetCall<'a, C, A> { PurchaseSubscriptionGetCall { hub: self.hub, _package_name: package_name.to_string(), @@ -1388,7 +1384,7 @@ impl<'a, C, NC, A> PurchaseMethods<'a, C, NC, A> { /// * `packageName` - The package name of the application for which this subscription was purchased (for example, 'com.some.thing'). /// * `subscriptionId` - The purchased subscription ID (for example, 'monthly001'). /// * `token` - The token provided to the user's device when the subscription was purchased. - pub fn subscriptions_cancel(&self, package_name: &str, subscription_id: &str, token: &str) -> PurchaseSubscriptionCancelCall<'a, C, NC, A> { + pub fn subscriptions_cancel(&self, package_name: &str, subscription_id: &str, token: &str) -> PurchaseSubscriptionCancelCall<'a, C, A> { PurchaseSubscriptionCancelCall { hub: self.hub, _package_name: package_name.to_string(), @@ -1409,7 +1405,7 @@ impl<'a, C, NC, A> PurchaseMethods<'a, C, NC, A> { /// * `packageName` - The package name of the application for which this subscription was purchased (for example, 'com.some.thing'). /// * `subscriptionId` - The purchased subscription ID (for example, 'monthly001'). /// * `token` - The token provided to the user's device when the subscription was purchased. - pub fn subscriptions_refund(&self, package_name: &str, subscription_id: &str, token: &str) -> PurchaseSubscriptionRefundCall<'a, C, NC, A> { + pub fn subscriptions_refund(&self, package_name: &str, subscription_id: &str, token: &str) -> PurchaseSubscriptionRefundCall<'a, C, A> { PurchaseSubscriptionRefundCall { hub: self.hub, _package_name: package_name.to_string(), @@ -1431,7 +1427,7 @@ impl<'a, C, NC, A> PurchaseMethods<'a, C, NC, A> { /// * `packageName` - The package name of the application for which this subscription was purchased (for example, 'com.some.thing'). /// * `subscriptionId` - The purchased subscription ID (for example, 'monthly001'). /// * `token` - The token provided to the user's device when the subscription was purchased. - pub fn subscriptions_defer(&self, request: &SubscriptionPurchasesDeferRequest, package_name: &str, subscription_id: &str, token: &str) -> PurchaseSubscriptionDeferCall<'a, C, NC, A> { + pub fn subscriptions_defer(&self, request: &SubscriptionPurchasesDeferRequest, package_name: &str, subscription_id: &str, token: &str) -> PurchaseSubscriptionDeferCall<'a, C, A> { PurchaseSubscriptionDeferCall { hub: self.hub, _request: request.clone(), @@ -1475,15 +1471,15 @@ impl<'a, C, NC, A> PurchaseMethods<'a, C, NC, A> { /// let rb = hub.edits(); /// # } /// ``` -pub struct EditMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, } -impl<'a, C, NC, A> MethodsBuilder for EditMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for EditMethods<'a, C, A> {} -impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { +impl<'a, C, A> EditMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1495,7 +1491,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `editId` - Unique identifier for this edit. /// * `language` - The language code (a BCP-47 language tag) of the localized listing whose images are to read or modified. For example, to select Austrian German, pass "de-AT". /// * `imageType` - No description provided. - pub fn images_upload(&self, package_name: &str, edit_id: &str, language: &str, image_type: &str) -> EditImageUploadCall<'a, C, NC, A> { + pub fn images_upload(&self, package_name: &str, edit_id: &str, language: &str, image_type: &str) -> EditImageUploadCall<'a, C, A> { EditImageUploadCall { hub: self.hub, _package_name: package_name.to_string(), @@ -1519,7 +1515,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `editId` - Unique identifier for this edit. /// * `apkVersionCode` - The version code of the APK whose Expansion File configuration is being read or modified. /// * `expansionFileType` - No description provided. - pub fn expansionfiles_update(&self, request: &ExpansionFile, package_name: &str, edit_id: &str, apk_version_code: i32, expansion_file_type: &str) -> EditExpansionfileUpdateCall<'a, C, NC, A> { + pub fn expansionfiles_update(&self, request: &ExpansionFile, package_name: &str, edit_id: &str, apk_version_code: i32, expansion_file_type: &str) -> EditExpansionfileUpdateCall<'a, C, A> { EditExpansionfileUpdateCall { hub: self.hub, _request: request.clone(), @@ -1541,7 +1537,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. - pub fn details_get(&self, package_name: &str, edit_id: &str) -> EditDetailGetCall<'a, C, NC, A> { + pub fn details_get(&self, package_name: &str, edit_id: &str) -> EditDetailGetCall<'a, C, A> { EditDetailGetCall { hub: self.hub, _package_name: package_name.to_string(), @@ -1562,7 +1558,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `editId` - Unique identifier for this edit. /// * `apkVersionCode` - The APK version code whose APK-specific listings should be read or modified. /// * `language` - The language code (a BCP-47 language tag) of the APK-specific localized listing to read or modify. For example, to select Austrian German, pass "de-AT". - pub fn apklistings_delete(&self, package_name: &str, edit_id: &str, apk_version_code: i32, language: &str) -> EditApklistingDeleteCall<'a, C, NC, A> { + pub fn apklistings_delete(&self, package_name: &str, edit_id: &str, apk_version_code: i32, language: &str) -> EditApklistingDeleteCall<'a, C, A> { EditApklistingDeleteCall { hub: self.hub, _package_name: package_name.to_string(), @@ -1583,7 +1579,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. - pub fn listings_deleteall(&self, package_name: &str, edit_id: &str) -> EditListingDeleteallCall<'a, C, NC, A> { + pub fn listings_deleteall(&self, package_name: &str, edit_id: &str) -> EditListingDeleteallCall<'a, C, A> { EditListingDeleteallCall { hub: self.hub, _package_name: package_name.to_string(), @@ -1603,7 +1599,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. - pub fn apks_addexternallyhosted(&self, request: &ApksAddExternallyHostedRequest, package_name: &str, edit_id: &str) -> EditApkAddexternallyhostedCall<'a, C, NC, A> { + pub fn apks_addexternallyhosted(&self, request: &ApksAddExternallyHostedRequest, package_name: &str, edit_id: &str) -> EditApkAddexternallyhostedCall<'a, C, A> { EditApkAddexternallyhostedCall { hub: self.hub, _request: request.clone(), @@ -1624,7 +1620,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. /// * `apkVersionCode` - The APK version code whose APK-specific listings should be read or modified. - pub fn apklistings_deleteall(&self, package_name: &str, edit_id: &str, apk_version_code: i32) -> EditApklistingDeleteallCall<'a, C, NC, A> { + pub fn apklistings_deleteall(&self, package_name: &str, edit_id: &str, apk_version_code: i32) -> EditApklistingDeleteallCall<'a, C, A> { EditApklistingDeleteallCall { hub: self.hub, _package_name: package_name.to_string(), @@ -1645,7 +1641,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. - pub fn details_update(&self, request: &AppDetails, package_name: &str, edit_id: &str) -> EditDetailUpdateCall<'a, C, NC, A> { + pub fn details_update(&self, request: &AppDetails, package_name: &str, edit_id: &str) -> EditDetailUpdateCall<'a, C, A> { EditDetailUpdateCall { hub: self.hub, _request: request.clone(), @@ -1666,7 +1662,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. /// * `track` - The track type to read or modify. - pub fn tracks_get(&self, package_name: &str, edit_id: &str, track: &str) -> EditTrackGetCall<'a, C, NC, A> { + pub fn tracks_get(&self, package_name: &str, edit_id: &str, track: &str) -> EditTrackGetCall<'a, C, A> { EditTrackGetCall { hub: self.hub, _package_name: package_name.to_string(), @@ -1689,7 +1685,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `editId` - Unique identifier for this edit. /// * `apkVersionCode` - The version code of the APK whose Expansion File configuration is being read or modified. /// * `expansionFileType` - No description provided. - pub fn expansionfiles_patch(&self, request: &ExpansionFile, package_name: &str, edit_id: &str, apk_version_code: i32, expansion_file_type: &str) -> EditExpansionfilePatchCall<'a, C, NC, A> { + pub fn expansionfiles_patch(&self, request: &ExpansionFile, package_name: &str, edit_id: &str, apk_version_code: i32, expansion_file_type: &str) -> EditExpansionfilePatchCall<'a, C, A> { EditExpansionfilePatchCall { hub: self.hub, _request: request.clone(), @@ -1713,7 +1709,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `editId` - Unique identifier for this edit. /// * `language` - The language code (a BCP-47 language tag) of the localized listing whose images are to read or modified. For example, to select Austrian German, pass "de-AT". /// * `imageType` - No description provided. - pub fn images_list(&self, package_name: &str, edit_id: &str, language: &str, image_type: &str) -> EditImageListCall<'a, C, NC, A> { + pub fn images_list(&self, package_name: &str, edit_id: &str, language: &str, image_type: &str) -> EditImageListCall<'a, C, A> { EditImageListCall { hub: self.hub, _package_name: package_name.to_string(), @@ -1736,7 +1732,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. /// * `track` - The track type to read or modify. - pub fn tracks_update(&self, request: &Track, package_name: &str, edit_id: &str, track: &str) -> EditTrackUpdateCall<'a, C, NC, A> { + pub fn tracks_update(&self, request: &Track, package_name: &str, edit_id: &str, track: &str) -> EditTrackUpdateCall<'a, C, A> { EditTrackUpdateCall { hub: self.hub, _request: request.clone(), @@ -1759,7 +1755,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. /// * `language` - The language code (a BCP-47 language tag) of the localized listing to read or modify. For example, to select Austrian German, pass "de-AT". - pub fn listings_patch(&self, request: &Listing, package_name: &str, edit_id: &str, language: &str) -> EditListingPatchCall<'a, C, NC, A> { + pub fn listings_patch(&self, request: &Listing, package_name: &str, edit_id: &str, language: &str) -> EditListingPatchCall<'a, C, A> { EditListingPatchCall { hub: self.hub, _request: request.clone(), @@ -1780,7 +1776,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. - pub fn get(&self, package_name: &str, edit_id: &str) -> EditGetCall<'a, C, NC, A> { + pub fn get(&self, package_name: &str, edit_id: &str) -> EditGetCall<'a, C, A> { EditGetCall { hub: self.hub, _package_name: package_name.to_string(), @@ -1802,7 +1798,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `language` - The language code (a BCP-47 language tag) of the localized listing whose images are to read or modified. For example, to select Austrian German, pass "de-AT". /// * `imageType` - No description provided. /// * `imageId` - Unique identifier an image within the set of images attached to this edit. - pub fn images_delete(&self, package_name: &str, edit_id: &str, language: &str, image_type: &str, image_id: &str) -> EditImageDeleteCall<'a, C, NC, A> { + pub fn images_delete(&self, package_name: &str, edit_id: &str, language: &str, image_type: &str, image_id: &str) -> EditImageDeleteCall<'a, C, A> { EditImageDeleteCall { hub: self.hub, _package_name: package_name.to_string(), @@ -1821,7 +1817,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. - pub fn apks_upload(&self, package_name: &str, edit_id: &str) -> EditApkUploadCall<'a, C, NC, A> { + pub fn apks_upload(&self, package_name: &str, edit_id: &str) -> EditApkUploadCall<'a, C, A> { EditApkUploadCall { hub: self.hub, _package_name: package_name.to_string(), @@ -1843,7 +1839,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `editId` - Unique identifier for this edit. /// * `apkVersionCode` - The APK version code whose APK-specific listings should be read or modified. /// * `language` - The language code (a BCP-47 language tag) of the APK-specific localized listing to read or modify. For example, to select Austrian German, pass "de-AT". - pub fn apklistings_update(&self, request: &ApkListing, package_name: &str, edit_id: &str, apk_version_code: i32, language: &str) -> EditApklistingUpdateCall<'a, C, NC, A> { + pub fn apklistings_update(&self, request: &ApkListing, package_name: &str, edit_id: &str, apk_version_code: i32, language: &str) -> EditApklistingUpdateCall<'a, C, A> { EditApklistingUpdateCall { hub: self.hub, _request: request.clone(), @@ -1862,7 +1858,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. - pub fn apks_list(&self, package_name: &str, edit_id: &str) -> EditApkListCall<'a, C, NC, A> { + pub fn apks_list(&self, package_name: &str, edit_id: &str) -> EditApkListCall<'a, C, A> { EditApkListCall { hub: self.hub, _package_name: package_name.to_string(), @@ -1884,7 +1880,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `editId` - Unique identifier for this edit. /// * `apkVersionCode` - The APK version code whose APK-specific listings should be read or modified. /// * `language` - The language code (a BCP-47 language tag) of the APK-specific localized listing to read or modify. For example, to select Austrian German, pass "de-AT". - pub fn apklistings_patch(&self, request: &ApkListing, package_name: &str, edit_id: &str, apk_version_code: i32, language: &str) -> EditApklistingPatchCall<'a, C, NC, A> { + pub fn apklistings_patch(&self, request: &ApkListing, package_name: &str, edit_id: &str, apk_version_code: i32, language: &str) -> EditApklistingPatchCall<'a, C, A> { EditApklistingPatchCall { hub: self.hub, _request: request.clone(), @@ -1907,7 +1903,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. /// * `language` - The language code (a BCP-47 language tag) of the localized listing to read or modify. For example, to select Austrian German, pass "de-AT". - pub fn listings_get(&self, package_name: &str, edit_id: &str, language: &str) -> EditListingGetCall<'a, C, NC, A> { + pub fn listings_get(&self, package_name: &str, edit_id: &str, language: &str) -> EditListingGetCall<'a, C, A> { EditListingGetCall { hub: self.hub, _package_name: package_name.to_string(), @@ -1925,7 +1921,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. /// * `track` - No description provided. - pub fn testers_get(&self, package_name: &str, edit_id: &str, track: &str) -> EditTesterGetCall<'a, C, NC, A> { + pub fn testers_get(&self, package_name: &str, edit_id: &str, track: &str) -> EditTesterGetCall<'a, C, A> { EditTesterGetCall { hub: self.hub, _package_name: package_name.to_string(), @@ -1945,7 +1941,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. - pub fn delete(&self, package_name: &str, edit_id: &str) -> EditDeleteCall<'a, C, NC, A> { + pub fn delete(&self, package_name: &str, edit_id: &str) -> EditDeleteCall<'a, C, A> { EditDeleteCall { hub: self.hub, _package_name: package_name.to_string(), @@ -1966,7 +1962,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `editId` - Unique identifier for this edit. /// * `apkVersionCode` - The version code of the APK whose Expansion File configuration is being read or modified. /// * `expansionFileType` - No description provided. - pub fn expansionfiles_upload(&self, package_name: &str, edit_id: &str, apk_version_code: i32, expansion_file_type: &str) -> EditExpansionfileUploadCall<'a, C, NC, A> { + pub fn expansionfiles_upload(&self, package_name: &str, edit_id: &str, apk_version_code: i32, expansion_file_type: &str) -> EditExpansionfileUploadCall<'a, C, A> { EditExpansionfileUploadCall { hub: self.hub, _package_name: package_name.to_string(), @@ -1987,7 +1983,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn insert(&self, request: &AppEdit, package_name: &str) -> EditInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &AppEdit, package_name: &str) -> EditInsertCall<'a, C, A> { EditInsertCall { hub: self.hub, _request: request.clone(), @@ -2006,7 +2002,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. - pub fn listings_list(&self, package_name: &str, edit_id: &str) -> EditListingListCall<'a, C, NC, A> { + pub fn listings_list(&self, package_name: &str, edit_id: &str) -> EditListingListCall<'a, C, A> { EditListingListCall { hub: self.hub, _package_name: package_name.to_string(), @@ -2024,7 +2020,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. /// * `track` - No description provided. - pub fn testers_patch(&self, request: &Testers, package_name: &str, edit_id: &str, track: &str) -> EditTesterPatchCall<'a, C, NC, A> { + pub fn testers_patch(&self, request: &Testers, package_name: &str, edit_id: &str, track: &str) -> EditTesterPatchCall<'a, C, A> { EditTesterPatchCall { hub: self.hub, _request: request.clone(), @@ -2045,7 +2041,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. - pub fn commit(&self, package_name: &str, edit_id: &str) -> EditCommitCall<'a, C, NC, A> { + pub fn commit(&self, package_name: &str, edit_id: &str) -> EditCommitCall<'a, C, A> { EditCommitCall { hub: self.hub, _package_name: package_name.to_string(), @@ -2064,7 +2060,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. - pub fn tracks_list(&self, package_name: &str, edit_id: &str) -> EditTrackListCall<'a, C, NC, A> { + pub fn tracks_list(&self, package_name: &str, edit_id: &str) -> EditTrackListCall<'a, C, A> { EditTrackListCall { hub: self.hub, _package_name: package_name.to_string(), @@ -2083,7 +2079,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. - pub fn validate(&self, package_name: &str, edit_id: &str) -> EditValidateCall<'a, C, NC, A> { + pub fn validate(&self, package_name: &str, edit_id: &str) -> EditValidateCall<'a, C, A> { EditValidateCall { hub: self.hub, _package_name: package_name.to_string(), @@ -2104,7 +2100,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. /// * `language` - The language code (a BCP-47 language tag) of the localized listing to read or modify. For example, to select Austrian German, pass "de-AT". - pub fn listings_update(&self, request: &Listing, package_name: &str, edit_id: &str, language: &str) -> EditListingUpdateCall<'a, C, NC, A> { + pub fn listings_update(&self, request: &Listing, package_name: &str, edit_id: &str, language: &str) -> EditListingUpdateCall<'a, C, A> { EditListingUpdateCall { hub: self.hub, _request: request.clone(), @@ -2127,7 +2123,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `editId` - Unique identifier for this edit. /// * `apkVersionCode` - The version code of the APK whose Expansion File configuration is being read or modified. /// * `expansionFileType` - No description provided. - pub fn expansionfiles_get(&self, package_name: &str, edit_id: &str, apk_version_code: i32, expansion_file_type: &str) -> EditExpansionfileGetCall<'a, C, NC, A> { + pub fn expansionfiles_get(&self, package_name: &str, edit_id: &str, apk_version_code: i32, expansion_file_type: &str) -> EditExpansionfileGetCall<'a, C, A> { EditExpansionfileGetCall { hub: self.hub, _package_name: package_name.to_string(), @@ -2150,7 +2146,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `editId` - Unique identifier for this edit. /// * `language` - The language code (a BCP-47 language tag) of the localized listing whose images are to read or modified. For example, to select Austrian German, pass "de-AT". /// * `imageType` - No description provided. - pub fn images_deleteall(&self, package_name: &str, edit_id: &str, language: &str, image_type: &str) -> EditImageDeleteallCall<'a, C, NC, A> { + pub fn images_deleteall(&self, package_name: &str, edit_id: &str, language: &str, image_type: &str) -> EditImageDeleteallCall<'a, C, A> { EditImageDeleteallCall { hub: self.hub, _package_name: package_name.to_string(), @@ -2172,7 +2168,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. - pub fn details_patch(&self, request: &AppDetails, package_name: &str, edit_id: &str) -> EditDetailPatchCall<'a, C, NC, A> { + pub fn details_patch(&self, request: &AppDetails, package_name: &str, edit_id: &str) -> EditDetailPatchCall<'a, C, A> { EditDetailPatchCall { hub: self.hub, _request: request.clone(), @@ -2194,7 +2190,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. /// * `track` - The track type to read or modify. - pub fn tracks_patch(&self, request: &Track, package_name: &str, edit_id: &str, track: &str) -> EditTrackPatchCall<'a, C, NC, A> { + pub fn tracks_patch(&self, request: &Track, package_name: &str, edit_id: &str, track: &str) -> EditTrackPatchCall<'a, C, A> { EditTrackPatchCall { hub: self.hub, _request: request.clone(), @@ -2216,7 +2212,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. /// * `language` - The language code (a BCP-47 language tag) of the localized listing to read or modify. For example, to select Austrian German, pass "de-AT". - pub fn listings_delete(&self, package_name: &str, edit_id: &str, language: &str) -> EditListingDeleteCall<'a, C, NC, A> { + pub fn listings_delete(&self, package_name: &str, edit_id: &str, language: &str) -> EditListingDeleteCall<'a, C, A> { EditListingDeleteCall { hub: self.hub, _package_name: package_name.to_string(), @@ -2238,7 +2234,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `editId` - Unique identifier for this edit. /// * `apkVersionCode` - The APK version code whose APK-specific listings should be read or modified. /// * `language` - The language code (a BCP-47 language tag) of the APK-specific localized listing to read or modify. For example, to select Austrian German, pass "de-AT". - pub fn apklistings_get(&self, package_name: &str, edit_id: &str, apk_version_code: i32, language: &str) -> EditApklistingGetCall<'a, C, NC, A> { + pub fn apklistings_get(&self, package_name: &str, edit_id: &str, apk_version_code: i32, language: &str) -> EditApklistingGetCall<'a, C, A> { EditApklistingGetCall { hub: self.hub, _package_name: package_name.to_string(), @@ -2258,7 +2254,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. /// * `track` - No description provided. - pub fn testers_update(&self, request: &Testers, package_name: &str, edit_id: &str, track: &str) -> EditTesterUpdateCall<'a, C, NC, A> { + pub fn testers_update(&self, request: &Testers, package_name: &str, edit_id: &str, track: &str) -> EditTesterUpdateCall<'a, C, A> { EditTesterUpdateCall { hub: self.hub, _request: request.clone(), @@ -2280,7 +2276,7 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// * `packageName` - Unique identifier for the Android app that is being updated; for example, "com.spiffygame". /// * `editId` - Unique identifier for this edit. /// * `apkVersionCode` - The APK version code whose APK-specific listings should be read or modified. - pub fn apklistings_list(&self, package_name: &str, edit_id: &str, apk_version_code: i32) -> EditApklistingListCall<'a, C, NC, A> { + pub fn apklistings_list(&self, package_name: &str, edit_id: &str, apk_version_code: i32) -> EditApklistingListCall<'a, C, A> { EditApklistingListCall { hub: self.hub, _package_name: package_name.to_string(), @@ -2323,21 +2319,21 @@ impl<'a, C, NC, A> EditMethods<'a, C, NC, A> { /// let rb = hub.inappproducts(); /// # } /// ``` -pub struct InappproductMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InappproductMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, } -impl<'a, C, NC, A> MethodsBuilder for InappproductMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for InappproductMethods<'a, C, A> {} -impl<'a, C, NC, A> InappproductMethods<'a, C, NC, A> { +impl<'a, C, A> InappproductMethods<'a, C, A> { /// /// # Arguments /// /// * `request` - No description provided. - pub fn batch(&self, request: &InappproductsBatchRequest) -> InappproductBatchCall<'a, C, NC, A> { + pub fn batch(&self, request: &InappproductsBatchRequest) -> InappproductBatchCall<'a, C, A> { InappproductBatchCall { hub: self.hub, _request: request.clone(), @@ -2354,7 +2350,7 @@ impl<'a, C, NC, A> InappproductMethods<'a, C, NC, A> { /// # Arguments /// /// * `packageName` - Unique identifier for the Android app with in-app products; for example, "com.spiffygame". - pub fn list(&self, package_name: &str) -> InappproductListCall<'a, C, NC, A> { + pub fn list(&self, package_name: &str) -> InappproductListCall<'a, C, A> { InappproductListCall { hub: self.hub, _package_name: package_name.to_string(), @@ -2375,7 +2371,7 @@ impl<'a, C, NC, A> InappproductMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `packageName` - Unique identifier for the Android app; for example, "com.spiffygame". - pub fn insert(&self, request: &InAppProduct, package_name: &str) -> InappproductInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &InAppProduct, package_name: &str) -> InappproductInsertCall<'a, C, A> { InappproductInsertCall { hub: self.hub, _request: request.clone(), @@ -2395,7 +2391,7 @@ impl<'a, C, NC, A> InappproductMethods<'a, C, NC, A> { /// /// * `packageName` - Unique identifier for the Android app with the in-app product; for example, "com.spiffygame". /// * `sku` - Unique identifier for the in-app product. - pub fn delete(&self, package_name: &str, sku: &str) -> InappproductDeleteCall<'a, C, NC, A> { + pub fn delete(&self, package_name: &str, sku: &str) -> InappproductDeleteCall<'a, C, A> { InappproductDeleteCall { hub: self.hub, _package_name: package_name.to_string(), @@ -2414,7 +2410,7 @@ impl<'a, C, NC, A> InappproductMethods<'a, C, NC, A> { /// /// * `packageName` - No description provided. /// * `sku` - Unique identifier for the in-app product. - pub fn get(&self, package_name: &str, sku: &str) -> InappproductGetCall<'a, C, NC, A> { + pub fn get(&self, package_name: &str, sku: &str) -> InappproductGetCall<'a, C, A> { InappproductGetCall { hub: self.hub, _package_name: package_name.to_string(), @@ -2434,7 +2430,7 @@ impl<'a, C, NC, A> InappproductMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `packageName` - Unique identifier for the Android app with the in-app product; for example, "com.spiffygame". /// * `sku` - Unique identifier for the in-app product. - pub fn update(&self, request: &InAppProduct, package_name: &str, sku: &str) -> InappproductUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &InAppProduct, package_name: &str, sku: &str) -> InappproductUpdateCall<'a, C, A> { InappproductUpdateCall { hub: self.hub, _request: request.clone(), @@ -2456,7 +2452,7 @@ impl<'a, C, NC, A> InappproductMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `packageName` - Unique identifier for the Android app with the in-app product; for example, "com.spiffygame". /// * `sku` - Unique identifier for the in-app product. - pub fn patch(&self, request: &InAppProduct, package_name: &str, sku: &str) -> InappproductPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &InAppProduct, package_name: &str, sku: &str) -> InappproductPatchCall<'a, C, A> { InappproductPatchCall { hub: self.hub, _request: request.clone(), @@ -2508,10 +2504,10 @@ impl<'a, C, NC, A> InappproductMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct PurchaseSubscriptionRevokeCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PurchaseSubscriptionRevokeCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _subscription_id: String, _token: String, @@ -2520,9 +2516,9 @@ pub struct PurchaseSubscriptionRevokeCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PurchaseSubscriptionRevokeCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PurchaseSubscriptionRevokeCall<'a, C, A> {} -impl<'a, C, NC, A> PurchaseSubscriptionRevokeCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PurchaseSubscriptionRevokeCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2645,7 +2641,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionRevokeCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The package name of the application for which this subscription was purchased (for example, 'com.some.thing'). - pub fn package_name(mut self, new_value: &str) -> PurchaseSubscriptionRevokeCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> PurchaseSubscriptionRevokeCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -2655,7 +2651,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionRevokeCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The purchased subscription ID (for example, 'monthly001'). - pub fn subscription_id(mut self, new_value: &str) -> PurchaseSubscriptionRevokeCall<'a, C, NC, A> { + pub fn subscription_id(mut self, new_value: &str) -> PurchaseSubscriptionRevokeCall<'a, C, A> { self._subscription_id = new_value.to_string(); self } @@ -2665,7 +2661,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionRevokeCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The token provided to the user's device when the subscription was purchased. - pub fn token(mut self, new_value: &str) -> PurchaseSubscriptionRevokeCall<'a, C, NC, A> { + pub fn token(mut self, new_value: &str) -> PurchaseSubscriptionRevokeCall<'a, C, A> { self._token = new_value.to_string(); self } @@ -2676,7 +2672,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionRevokeCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PurchaseSubscriptionRevokeCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PurchaseSubscriptionRevokeCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2697,7 +2693,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionRevokeCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PurchaseSubscriptionRevokeCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PurchaseSubscriptionRevokeCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2714,7 +2710,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionRevokeCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PurchaseSubscriptionRevokeCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PurchaseSubscriptionRevokeCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2752,10 +2748,10 @@ impl<'a, C, NC, A> PurchaseSubscriptionRevokeCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct PurchaseProductGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PurchaseProductGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _product_id: String, _token: String, @@ -2764,9 +2760,9 @@ pub struct PurchaseProductGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PurchaseProductGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PurchaseProductGetCall<'a, C, A> {} -impl<'a, C, NC, A> PurchaseProductGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PurchaseProductGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2900,7 +2896,7 @@ impl<'a, C, NC, A> PurchaseProductGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The package name of the application the inapp product was sold in (for example, 'com.some.thing'). - pub fn package_name(mut self, new_value: &str) -> PurchaseProductGetCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> PurchaseProductGetCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -2910,7 +2906,7 @@ impl<'a, C, NC, A> PurchaseProductGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The inapp product SKU (for example, 'com.some.thing.inapp1'). - pub fn product_id(mut self, new_value: &str) -> PurchaseProductGetCall<'a, C, NC, A> { + pub fn product_id(mut self, new_value: &str) -> PurchaseProductGetCall<'a, C, A> { self._product_id = new_value.to_string(); self } @@ -2920,7 +2916,7 @@ impl<'a, C, NC, A> PurchaseProductGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The token provided to the user's device when the inapp product was purchased. - pub fn token(mut self, new_value: &str) -> PurchaseProductGetCall<'a, C, NC, A> { + pub fn token(mut self, new_value: &str) -> PurchaseProductGetCall<'a, C, A> { self._token = new_value.to_string(); self } @@ -2931,7 +2927,7 @@ impl<'a, C, NC, A> PurchaseProductGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PurchaseProductGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PurchaseProductGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2952,7 +2948,7 @@ impl<'a, C, NC, A> PurchaseProductGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PurchaseProductGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PurchaseProductGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2969,7 +2965,7 @@ impl<'a, C, NC, A> PurchaseProductGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PurchaseProductGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PurchaseProductGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3007,10 +3003,10 @@ impl<'a, C, NC, A> PurchaseProductGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct PurchaseSubscriptionGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PurchaseSubscriptionGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _subscription_id: String, _token: String, @@ -3019,9 +3015,9 @@ pub struct PurchaseSubscriptionGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PurchaseSubscriptionGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PurchaseSubscriptionGetCall<'a, C, A> {} -impl<'a, C, NC, A> PurchaseSubscriptionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PurchaseSubscriptionGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3155,7 +3151,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The package name of the application for which this subscription was purchased (for example, 'com.some.thing'). - pub fn package_name(mut self, new_value: &str) -> PurchaseSubscriptionGetCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> PurchaseSubscriptionGetCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -3165,7 +3161,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The purchased subscription ID (for example, 'monthly001'). - pub fn subscription_id(mut self, new_value: &str) -> PurchaseSubscriptionGetCall<'a, C, NC, A> { + pub fn subscription_id(mut self, new_value: &str) -> PurchaseSubscriptionGetCall<'a, C, A> { self._subscription_id = new_value.to_string(); self } @@ -3175,7 +3171,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The token provided to the user's device when the subscription was purchased. - pub fn token(mut self, new_value: &str) -> PurchaseSubscriptionGetCall<'a, C, NC, A> { + pub fn token(mut self, new_value: &str) -> PurchaseSubscriptionGetCall<'a, C, A> { self._token = new_value.to_string(); self } @@ -3186,7 +3182,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionGetCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PurchaseSubscriptionGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PurchaseSubscriptionGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3207,7 +3203,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionGetCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PurchaseSubscriptionGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PurchaseSubscriptionGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3224,7 +3220,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionGetCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PurchaseSubscriptionGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PurchaseSubscriptionGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3262,10 +3258,10 @@ impl<'a, C, NC, A> PurchaseSubscriptionGetCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct PurchaseSubscriptionCancelCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PurchaseSubscriptionCancelCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _subscription_id: String, _token: String, @@ -3274,9 +3270,9 @@ pub struct PurchaseSubscriptionCancelCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PurchaseSubscriptionCancelCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PurchaseSubscriptionCancelCall<'a, C, A> {} -impl<'a, C, NC, A> PurchaseSubscriptionCancelCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PurchaseSubscriptionCancelCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3399,7 +3395,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionCancelCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The package name of the application for which this subscription was purchased (for example, 'com.some.thing'). - pub fn package_name(mut self, new_value: &str) -> PurchaseSubscriptionCancelCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> PurchaseSubscriptionCancelCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -3409,7 +3405,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionCancelCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The purchased subscription ID (for example, 'monthly001'). - pub fn subscription_id(mut self, new_value: &str) -> PurchaseSubscriptionCancelCall<'a, C, NC, A> { + pub fn subscription_id(mut self, new_value: &str) -> PurchaseSubscriptionCancelCall<'a, C, A> { self._subscription_id = new_value.to_string(); self } @@ -3419,7 +3415,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionCancelCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The token provided to the user's device when the subscription was purchased. - pub fn token(mut self, new_value: &str) -> PurchaseSubscriptionCancelCall<'a, C, NC, A> { + pub fn token(mut self, new_value: &str) -> PurchaseSubscriptionCancelCall<'a, C, A> { self._token = new_value.to_string(); self } @@ -3430,7 +3426,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionCancelCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PurchaseSubscriptionCancelCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PurchaseSubscriptionCancelCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3451,7 +3447,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionCancelCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PurchaseSubscriptionCancelCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PurchaseSubscriptionCancelCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3468,7 +3464,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionCancelCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PurchaseSubscriptionCancelCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PurchaseSubscriptionCancelCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3506,10 +3502,10 @@ impl<'a, C, NC, A> PurchaseSubscriptionCancelCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct PurchaseSubscriptionRefundCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PurchaseSubscriptionRefundCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _subscription_id: String, _token: String, @@ -3518,9 +3514,9 @@ pub struct PurchaseSubscriptionRefundCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PurchaseSubscriptionRefundCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PurchaseSubscriptionRefundCall<'a, C, A> {} -impl<'a, C, NC, A> PurchaseSubscriptionRefundCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PurchaseSubscriptionRefundCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3643,7 +3639,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionRefundCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The package name of the application for which this subscription was purchased (for example, 'com.some.thing'). - pub fn package_name(mut self, new_value: &str) -> PurchaseSubscriptionRefundCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> PurchaseSubscriptionRefundCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -3653,7 +3649,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionRefundCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The purchased subscription ID (for example, 'monthly001'). - pub fn subscription_id(mut self, new_value: &str) -> PurchaseSubscriptionRefundCall<'a, C, NC, A> { + pub fn subscription_id(mut self, new_value: &str) -> PurchaseSubscriptionRefundCall<'a, C, A> { self._subscription_id = new_value.to_string(); self } @@ -3663,7 +3659,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionRefundCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The token provided to the user's device when the subscription was purchased. - pub fn token(mut self, new_value: &str) -> PurchaseSubscriptionRefundCall<'a, C, NC, A> { + pub fn token(mut self, new_value: &str) -> PurchaseSubscriptionRefundCall<'a, C, A> { self._token = new_value.to_string(); self } @@ -3674,7 +3670,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionRefundCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PurchaseSubscriptionRefundCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PurchaseSubscriptionRefundCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3695,7 +3691,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionRefundCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PurchaseSubscriptionRefundCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PurchaseSubscriptionRefundCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3712,7 +3708,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionRefundCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PurchaseSubscriptionRefundCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PurchaseSubscriptionRefundCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3756,10 +3752,10 @@ impl<'a, C, NC, A> PurchaseSubscriptionRefundCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct PurchaseSubscriptionDeferCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PurchaseSubscriptionDeferCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _request: SubscriptionPurchasesDeferRequest, _package_name: String, _subscription_id: String, @@ -3769,9 +3765,9 @@ pub struct PurchaseSubscriptionDeferCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PurchaseSubscriptionDeferCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PurchaseSubscriptionDeferCall<'a, C, A> {} -impl<'a, C, NC, A> PurchaseSubscriptionDeferCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PurchaseSubscriptionDeferCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3912,7 +3908,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionDeferCall<'a, C, NC, A> where NC: hyper:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &SubscriptionPurchasesDeferRequest) -> PurchaseSubscriptionDeferCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &SubscriptionPurchasesDeferRequest) -> PurchaseSubscriptionDeferCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3922,7 +3918,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionDeferCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The package name of the application for which this subscription was purchased (for example, 'com.some.thing'). - pub fn package_name(mut self, new_value: &str) -> PurchaseSubscriptionDeferCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> PurchaseSubscriptionDeferCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -3932,7 +3928,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionDeferCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The purchased subscription ID (for example, 'monthly001'). - pub fn subscription_id(mut self, new_value: &str) -> PurchaseSubscriptionDeferCall<'a, C, NC, A> { + pub fn subscription_id(mut self, new_value: &str) -> PurchaseSubscriptionDeferCall<'a, C, A> { self._subscription_id = new_value.to_string(); self } @@ -3942,7 +3938,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionDeferCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The token provided to the user's device when the subscription was purchased. - pub fn token(mut self, new_value: &str) -> PurchaseSubscriptionDeferCall<'a, C, NC, A> { + pub fn token(mut self, new_value: &str) -> PurchaseSubscriptionDeferCall<'a, C, A> { self._token = new_value.to_string(); self } @@ -3953,7 +3949,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionDeferCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PurchaseSubscriptionDeferCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PurchaseSubscriptionDeferCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3974,7 +3970,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionDeferCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PurchaseSubscriptionDeferCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PurchaseSubscriptionDeferCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3991,7 +3987,7 @@ impl<'a, C, NC, A> PurchaseSubscriptionDeferCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PurchaseSubscriptionDeferCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PurchaseSubscriptionDeferCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4030,10 +4026,10 @@ impl<'a, C, NC, A> PurchaseSubscriptionDeferCall<'a, C, NC, A> where NC: hyper:: /// .upload(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct EditImageUploadCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditImageUploadCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _language: String, @@ -4043,9 +4039,9 @@ pub struct EditImageUploadCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditImageUploadCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditImageUploadCall<'a, C, A> {} -impl<'a, C, NC, A> EditImageUploadCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditImageUploadCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4289,7 +4285,7 @@ impl<'a, C, NC, A> EditImageUploadCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditImageUploadCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditImageUploadCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -4299,7 +4295,7 @@ impl<'a, C, NC, A> EditImageUploadCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditImageUploadCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditImageUploadCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -4309,7 +4305,7 @@ impl<'a, C, NC, A> EditImageUploadCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The language code (a BCP-47 language tag) of the localized listing whose images are to read or modified. For example, to select Austrian German, pass "de-AT". - pub fn language(mut self, new_value: &str) -> EditImageUploadCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> EditImageUploadCall<'a, C, A> { self._language = new_value.to_string(); self } @@ -4318,7 +4314,7 @@ impl<'a, C, NC, A> EditImageUploadCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn image_type(mut self, new_value: &str) -> EditImageUploadCall<'a, C, NC, A> { + pub fn image_type(mut self, new_value: &str) -> EditImageUploadCall<'a, C, A> { self._image_type = new_value.to_string(); self } @@ -4329,7 +4325,7 @@ impl<'a, C, NC, A> EditImageUploadCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditImageUploadCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditImageUploadCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4350,7 +4346,7 @@ impl<'a, C, NC, A> EditImageUploadCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditImageUploadCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditImageUploadCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4367,7 +4363,7 @@ impl<'a, C, NC, A> EditImageUploadCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditImageUploadCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditImageUploadCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4411,10 +4407,10 @@ impl<'a, C, NC, A> EditImageUploadCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct EditExpansionfileUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditExpansionfileUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _request: ExpansionFile, _package_name: String, _edit_id: String, @@ -4425,9 +4421,9 @@ pub struct EditExpansionfileUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditExpansionfileUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditExpansionfileUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> EditExpansionfileUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditExpansionfileUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4569,7 +4565,7 @@ impl<'a, C, NC, A> EditExpansionfileUpdateCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ExpansionFile) -> EditExpansionfileUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ExpansionFile) -> EditExpansionfileUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4579,7 +4575,7 @@ impl<'a, C, NC, A> EditExpansionfileUpdateCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditExpansionfileUpdateCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditExpansionfileUpdateCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -4589,7 +4585,7 @@ impl<'a, C, NC, A> EditExpansionfileUpdateCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditExpansionfileUpdateCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditExpansionfileUpdateCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -4599,7 +4595,7 @@ impl<'a, C, NC, A> EditExpansionfileUpdateCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The version code of the APK whose Expansion File configuration is being read or modified. - pub fn apk_version_code(mut self, new_value: i32) -> EditExpansionfileUpdateCall<'a, C, NC, A> { + pub fn apk_version_code(mut self, new_value: i32) -> EditExpansionfileUpdateCall<'a, C, A> { self._apk_version_code = new_value; self } @@ -4608,7 +4604,7 @@ impl<'a, C, NC, A> EditExpansionfileUpdateCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn expansion_file_type(mut self, new_value: &str) -> EditExpansionfileUpdateCall<'a, C, NC, A> { + pub fn expansion_file_type(mut self, new_value: &str) -> EditExpansionfileUpdateCall<'a, C, A> { self._expansion_file_type = new_value.to_string(); self } @@ -4619,7 +4615,7 @@ impl<'a, C, NC, A> EditExpansionfileUpdateCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditExpansionfileUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditExpansionfileUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4640,7 +4636,7 @@ impl<'a, C, NC, A> EditExpansionfileUpdateCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditExpansionfileUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditExpansionfileUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4657,7 +4653,7 @@ impl<'a, C, NC, A> EditExpansionfileUpdateCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditExpansionfileUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditExpansionfileUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4695,10 +4691,10 @@ impl<'a, C, NC, A> EditExpansionfileUpdateCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct EditDetailGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditDetailGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _delegate: Option<&'a mut Delegate>, @@ -4706,9 +4702,9 @@ pub struct EditDetailGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditDetailGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditDetailGetCall<'a, C, A> {} -impl<'a, C, NC, A> EditDetailGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditDetailGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4841,7 +4837,7 @@ impl<'a, C, NC, A> EditDetailGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditDetailGetCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditDetailGetCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -4851,7 +4847,7 @@ impl<'a, C, NC, A> EditDetailGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditDetailGetCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditDetailGetCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -4862,7 +4858,7 @@ impl<'a, C, NC, A> EditDetailGetCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditDetailGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditDetailGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4883,7 +4879,7 @@ impl<'a, C, NC, A> EditDetailGetCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditDetailGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditDetailGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4900,7 +4896,7 @@ impl<'a, C, NC, A> EditDetailGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditDetailGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditDetailGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4938,10 +4934,10 @@ impl<'a, C, NC, A> EditDetailGetCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct EditApklistingDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditApklistingDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _apk_version_code: i32, @@ -4951,9 +4947,9 @@ pub struct EditApklistingDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditApklistingDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditApklistingDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> EditApklistingDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditApklistingDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5077,7 +5073,7 @@ impl<'a, C, NC, A> EditApklistingDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditApklistingDeleteCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditApklistingDeleteCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -5087,7 +5083,7 @@ impl<'a, C, NC, A> EditApklistingDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditApklistingDeleteCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditApklistingDeleteCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -5097,7 +5093,7 @@ impl<'a, C, NC, A> EditApklistingDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The APK version code whose APK-specific listings should be read or modified. - pub fn apk_version_code(mut self, new_value: i32) -> EditApklistingDeleteCall<'a, C, NC, A> { + pub fn apk_version_code(mut self, new_value: i32) -> EditApklistingDeleteCall<'a, C, A> { self._apk_version_code = new_value; self } @@ -5107,7 +5103,7 @@ impl<'a, C, NC, A> EditApklistingDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The language code (a BCP-47 language tag) of the APK-specific localized listing to read or modify. For example, to select Austrian German, pass "de-AT". - pub fn language(mut self, new_value: &str) -> EditApklistingDeleteCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> EditApklistingDeleteCall<'a, C, A> { self._language = new_value.to_string(); self } @@ -5118,7 +5114,7 @@ impl<'a, C, NC, A> EditApklistingDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditApklistingDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditApklistingDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5139,7 +5135,7 @@ impl<'a, C, NC, A> EditApklistingDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditApklistingDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditApklistingDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5156,7 +5152,7 @@ impl<'a, C, NC, A> EditApklistingDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditApklistingDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditApklistingDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5194,10 +5190,10 @@ impl<'a, C, NC, A> EditApklistingDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct EditListingDeleteallCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditListingDeleteallCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _delegate: Option<&'a mut Delegate>, @@ -5205,9 +5201,9 @@ pub struct EditListingDeleteallCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditListingDeleteallCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditListingDeleteallCall<'a, C, A> {} -impl<'a, C, NC, A> EditListingDeleteallCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditListingDeleteallCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5329,7 +5325,7 @@ impl<'a, C, NC, A> EditListingDeleteallCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditListingDeleteallCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditListingDeleteallCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -5339,7 +5335,7 @@ impl<'a, C, NC, A> EditListingDeleteallCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditListingDeleteallCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditListingDeleteallCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -5350,7 +5346,7 @@ impl<'a, C, NC, A> EditListingDeleteallCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditListingDeleteallCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditListingDeleteallCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5371,7 +5367,7 @@ impl<'a, C, NC, A> EditListingDeleteallCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditListingDeleteallCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditListingDeleteallCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5388,7 +5384,7 @@ impl<'a, C, NC, A> EditListingDeleteallCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditListingDeleteallCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditListingDeleteallCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5432,10 +5428,10 @@ impl<'a, C, NC, A> EditListingDeleteallCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct EditApkAddexternallyhostedCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditApkAddexternallyhostedCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _request: ApksAddExternallyHostedRequest, _package_name: String, _edit_id: String, @@ -5444,9 +5440,9 @@ pub struct EditApkAddexternallyhostedCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditApkAddexternallyhostedCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditApkAddexternallyhostedCall<'a, C, A> {} -impl<'a, C, NC, A> EditApkAddexternallyhostedCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditApkAddexternallyhostedCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5586,7 +5582,7 @@ impl<'a, C, NC, A> EditApkAddexternallyhostedCall<'a, C, NC, A> where NC: hyper: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ApksAddExternallyHostedRequest) -> EditApkAddexternallyhostedCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ApksAddExternallyHostedRequest) -> EditApkAddexternallyhostedCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5596,7 +5592,7 @@ impl<'a, C, NC, A> EditApkAddexternallyhostedCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditApkAddexternallyhostedCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditApkAddexternallyhostedCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -5606,7 +5602,7 @@ impl<'a, C, NC, A> EditApkAddexternallyhostedCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditApkAddexternallyhostedCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditApkAddexternallyhostedCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -5617,7 +5613,7 @@ impl<'a, C, NC, A> EditApkAddexternallyhostedCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditApkAddexternallyhostedCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditApkAddexternallyhostedCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5638,7 +5634,7 @@ impl<'a, C, NC, A> EditApkAddexternallyhostedCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditApkAddexternallyhostedCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditApkAddexternallyhostedCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5655,7 +5651,7 @@ impl<'a, C, NC, A> EditApkAddexternallyhostedCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditApkAddexternallyhostedCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditApkAddexternallyhostedCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5693,10 +5689,10 @@ impl<'a, C, NC, A> EditApkAddexternallyhostedCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct EditApklistingDeleteallCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditApklistingDeleteallCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _apk_version_code: i32, @@ -5705,9 +5701,9 @@ pub struct EditApklistingDeleteallCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditApklistingDeleteallCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditApklistingDeleteallCall<'a, C, A> {} -impl<'a, C, NC, A> EditApklistingDeleteallCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditApklistingDeleteallCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5830,7 +5826,7 @@ impl<'a, C, NC, A> EditApklistingDeleteallCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditApklistingDeleteallCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditApklistingDeleteallCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -5840,7 +5836,7 @@ impl<'a, C, NC, A> EditApklistingDeleteallCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditApklistingDeleteallCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditApklistingDeleteallCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -5850,7 +5846,7 @@ impl<'a, C, NC, A> EditApklistingDeleteallCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The APK version code whose APK-specific listings should be read or modified. - pub fn apk_version_code(mut self, new_value: i32) -> EditApklistingDeleteallCall<'a, C, NC, A> { + pub fn apk_version_code(mut self, new_value: i32) -> EditApklistingDeleteallCall<'a, C, A> { self._apk_version_code = new_value; self } @@ -5861,7 +5857,7 @@ impl<'a, C, NC, A> EditApklistingDeleteallCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditApklistingDeleteallCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditApklistingDeleteallCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5882,7 +5878,7 @@ impl<'a, C, NC, A> EditApklistingDeleteallCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditApklistingDeleteallCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditApklistingDeleteallCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5899,7 +5895,7 @@ impl<'a, C, NC, A> EditApklistingDeleteallCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditApklistingDeleteallCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditApklistingDeleteallCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5943,10 +5939,10 @@ impl<'a, C, NC, A> EditApklistingDeleteallCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct EditDetailUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditDetailUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _request: AppDetails, _package_name: String, _edit_id: String, @@ -5955,9 +5951,9 @@ pub struct EditDetailUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditDetailUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditDetailUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> EditDetailUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditDetailUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6097,7 +6093,7 @@ impl<'a, C, NC, A> EditDetailUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AppDetails) -> EditDetailUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AppDetails) -> EditDetailUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6107,7 +6103,7 @@ impl<'a, C, NC, A> EditDetailUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditDetailUpdateCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditDetailUpdateCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -6117,7 +6113,7 @@ impl<'a, C, NC, A> EditDetailUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditDetailUpdateCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditDetailUpdateCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -6128,7 +6124,7 @@ impl<'a, C, NC, A> EditDetailUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditDetailUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditDetailUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6149,7 +6145,7 @@ impl<'a, C, NC, A> EditDetailUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditDetailUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditDetailUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6166,7 +6162,7 @@ impl<'a, C, NC, A> EditDetailUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditDetailUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditDetailUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6204,10 +6200,10 @@ impl<'a, C, NC, A> EditDetailUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct EditTrackGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditTrackGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _track: String, @@ -6216,9 +6212,9 @@ pub struct EditTrackGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditTrackGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditTrackGetCall<'a, C, A> {} -impl<'a, C, NC, A> EditTrackGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditTrackGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6352,7 +6348,7 @@ impl<'a, C, NC, A> EditTrackGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditTrackGetCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditTrackGetCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -6362,7 +6358,7 @@ impl<'a, C, NC, A> EditTrackGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditTrackGetCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditTrackGetCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -6372,7 +6368,7 @@ impl<'a, C, NC, A> EditTrackGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The track type to read or modify. - pub fn track(mut self, new_value: &str) -> EditTrackGetCall<'a, C, NC, A> { + pub fn track(mut self, new_value: &str) -> EditTrackGetCall<'a, C, A> { self._track = new_value.to_string(); self } @@ -6383,7 +6379,7 @@ impl<'a, C, NC, A> EditTrackGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditTrackGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditTrackGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6404,7 +6400,7 @@ impl<'a, C, NC, A> EditTrackGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditTrackGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditTrackGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6421,7 +6417,7 @@ impl<'a, C, NC, A> EditTrackGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditTrackGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditTrackGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6465,10 +6461,10 @@ impl<'a, C, NC, A> EditTrackGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct EditExpansionfilePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditExpansionfilePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _request: ExpansionFile, _package_name: String, _edit_id: String, @@ -6479,9 +6475,9 @@ pub struct EditExpansionfilePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditExpansionfilePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditExpansionfilePatchCall<'a, C, A> {} -impl<'a, C, NC, A> EditExpansionfilePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditExpansionfilePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6623,7 +6619,7 @@ impl<'a, C, NC, A> EditExpansionfilePatchCall<'a, C, NC, A> where NC: hyper::net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ExpansionFile) -> EditExpansionfilePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ExpansionFile) -> EditExpansionfilePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6633,7 +6629,7 @@ impl<'a, C, NC, A> EditExpansionfilePatchCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditExpansionfilePatchCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditExpansionfilePatchCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -6643,7 +6639,7 @@ impl<'a, C, NC, A> EditExpansionfilePatchCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditExpansionfilePatchCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditExpansionfilePatchCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -6653,7 +6649,7 @@ impl<'a, C, NC, A> EditExpansionfilePatchCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The version code of the APK whose Expansion File configuration is being read or modified. - pub fn apk_version_code(mut self, new_value: i32) -> EditExpansionfilePatchCall<'a, C, NC, A> { + pub fn apk_version_code(mut self, new_value: i32) -> EditExpansionfilePatchCall<'a, C, A> { self._apk_version_code = new_value; self } @@ -6662,7 +6658,7 @@ impl<'a, C, NC, A> EditExpansionfilePatchCall<'a, C, NC, A> where NC: hyper::net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn expansion_file_type(mut self, new_value: &str) -> EditExpansionfilePatchCall<'a, C, NC, A> { + pub fn expansion_file_type(mut self, new_value: &str) -> EditExpansionfilePatchCall<'a, C, A> { self._expansion_file_type = new_value.to_string(); self } @@ -6673,7 +6669,7 @@ impl<'a, C, NC, A> EditExpansionfilePatchCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditExpansionfilePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditExpansionfilePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6694,7 +6690,7 @@ impl<'a, C, NC, A> EditExpansionfilePatchCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditExpansionfilePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditExpansionfilePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6711,7 +6707,7 @@ impl<'a, C, NC, A> EditExpansionfilePatchCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditExpansionfilePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditExpansionfilePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6749,10 +6745,10 @@ impl<'a, C, NC, A> EditExpansionfilePatchCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct EditImageListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditImageListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _language: String, @@ -6762,9 +6758,9 @@ pub struct EditImageListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditImageListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditImageListCall<'a, C, A> {} -impl<'a, C, NC, A> EditImageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditImageListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6899,7 +6895,7 @@ impl<'a, C, NC, A> EditImageListCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditImageListCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditImageListCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -6909,7 +6905,7 @@ impl<'a, C, NC, A> EditImageListCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditImageListCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditImageListCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -6919,7 +6915,7 @@ impl<'a, C, NC, A> EditImageListCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The language code (a BCP-47 language tag) of the localized listing whose images are to read or modified. For example, to select Austrian German, pass "de-AT". - pub fn language(mut self, new_value: &str) -> EditImageListCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> EditImageListCall<'a, C, A> { self._language = new_value.to_string(); self } @@ -6928,7 +6924,7 @@ impl<'a, C, NC, A> EditImageListCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn image_type(mut self, new_value: &str) -> EditImageListCall<'a, C, NC, A> { + pub fn image_type(mut self, new_value: &str) -> EditImageListCall<'a, C, A> { self._image_type = new_value.to_string(); self } @@ -6939,7 +6935,7 @@ impl<'a, C, NC, A> EditImageListCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditImageListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditImageListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6960,7 +6956,7 @@ impl<'a, C, NC, A> EditImageListCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditImageListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditImageListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6977,7 +6973,7 @@ impl<'a, C, NC, A> EditImageListCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditImageListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditImageListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7021,10 +7017,10 @@ impl<'a, C, NC, A> EditImageListCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct EditTrackUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditTrackUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _request: Track, _package_name: String, _edit_id: String, @@ -7034,9 +7030,9 @@ pub struct EditTrackUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditTrackUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditTrackUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> EditTrackUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditTrackUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7177,7 +7173,7 @@ impl<'a, C, NC, A> EditTrackUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Track) -> EditTrackUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Track) -> EditTrackUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7187,7 +7183,7 @@ impl<'a, C, NC, A> EditTrackUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditTrackUpdateCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditTrackUpdateCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -7197,7 +7193,7 @@ impl<'a, C, NC, A> EditTrackUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditTrackUpdateCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditTrackUpdateCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -7207,7 +7203,7 @@ impl<'a, C, NC, A> EditTrackUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The track type to read or modify. - pub fn track(mut self, new_value: &str) -> EditTrackUpdateCall<'a, C, NC, A> { + pub fn track(mut self, new_value: &str) -> EditTrackUpdateCall<'a, C, A> { self._track = new_value.to_string(); self } @@ -7218,7 +7214,7 @@ impl<'a, C, NC, A> EditTrackUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditTrackUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditTrackUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7239,7 +7235,7 @@ impl<'a, C, NC, A> EditTrackUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditTrackUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditTrackUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7256,7 +7252,7 @@ impl<'a, C, NC, A> EditTrackUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditTrackUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditTrackUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7300,10 +7296,10 @@ impl<'a, C, NC, A> EditTrackUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct EditListingPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditListingPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _request: Listing, _package_name: String, _edit_id: String, @@ -7313,9 +7309,9 @@ pub struct EditListingPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditListingPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditListingPatchCall<'a, C, A> {} -impl<'a, C, NC, A> EditListingPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditListingPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7456,7 +7452,7 @@ impl<'a, C, NC, A> EditListingPatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Listing) -> EditListingPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Listing) -> EditListingPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7466,7 +7462,7 @@ impl<'a, C, NC, A> EditListingPatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditListingPatchCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditListingPatchCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -7476,7 +7472,7 @@ impl<'a, C, NC, A> EditListingPatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditListingPatchCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditListingPatchCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -7486,7 +7482,7 @@ impl<'a, C, NC, A> EditListingPatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The language code (a BCP-47 language tag) of the localized listing to read or modify. For example, to select Austrian German, pass "de-AT". - pub fn language(mut self, new_value: &str) -> EditListingPatchCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> EditListingPatchCall<'a, C, A> { self._language = new_value.to_string(); self } @@ -7497,7 +7493,7 @@ impl<'a, C, NC, A> EditListingPatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditListingPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditListingPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7518,7 +7514,7 @@ impl<'a, C, NC, A> EditListingPatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditListingPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditListingPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7535,7 +7531,7 @@ impl<'a, C, NC, A> EditListingPatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditListingPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditListingPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7573,10 +7569,10 @@ impl<'a, C, NC, A> EditListingPatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct EditGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _delegate: Option<&'a mut Delegate>, @@ -7584,9 +7580,9 @@ pub struct EditGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditGetCall<'a, C, A> {} -impl<'a, C, NC, A> EditGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7719,7 +7715,7 @@ impl<'a, C, NC, A> EditGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditGetCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditGetCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -7729,7 +7725,7 @@ impl<'a, C, NC, A> EditGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditGetCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditGetCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -7740,7 +7736,7 @@ impl<'a, C, NC, A> EditGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7761,7 +7757,7 @@ impl<'a, C, NC, A> EditGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7778,7 +7774,7 @@ impl<'a, C, NC, A> EditGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7816,10 +7812,10 @@ impl<'a, C, NC, A> EditGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct EditImageDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditImageDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _language: String, @@ -7830,9 +7826,9 @@ pub struct EditImageDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditImageDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditImageDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> EditImageDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditImageDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7957,7 +7953,7 @@ impl<'a, C, NC, A> EditImageDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditImageDeleteCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditImageDeleteCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -7967,7 +7963,7 @@ impl<'a, C, NC, A> EditImageDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditImageDeleteCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditImageDeleteCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -7977,7 +7973,7 @@ impl<'a, C, NC, A> EditImageDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The language code (a BCP-47 language tag) of the localized listing whose images are to read or modified. For example, to select Austrian German, pass "de-AT". - pub fn language(mut self, new_value: &str) -> EditImageDeleteCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> EditImageDeleteCall<'a, C, A> { self._language = new_value.to_string(); self } @@ -7986,7 +7982,7 @@ impl<'a, C, NC, A> EditImageDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn image_type(mut self, new_value: &str) -> EditImageDeleteCall<'a, C, NC, A> { + pub fn image_type(mut self, new_value: &str) -> EditImageDeleteCall<'a, C, A> { self._image_type = new_value.to_string(); self } @@ -7996,7 +7992,7 @@ impl<'a, C, NC, A> EditImageDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Unique identifier an image within the set of images attached to this edit. - pub fn image_id(mut self, new_value: &str) -> EditImageDeleteCall<'a, C, NC, A> { + pub fn image_id(mut self, new_value: &str) -> EditImageDeleteCall<'a, C, A> { self._image_id = new_value.to_string(); self } @@ -8007,7 +8003,7 @@ impl<'a, C, NC, A> EditImageDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditImageDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditImageDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8028,7 +8024,7 @@ impl<'a, C, NC, A> EditImageDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditImageDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditImageDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8045,7 +8041,7 @@ impl<'a, C, NC, A> EditImageDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditImageDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditImageDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8082,10 +8078,10 @@ impl<'a, C, NC, A> EditImageDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .upload_resumable(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct EditApkUploadCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditApkUploadCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _delegate: Option<&'a mut Delegate>, @@ -8093,9 +8089,9 @@ pub struct EditApkUploadCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditApkUploadCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditApkUploadCall<'a, C, A> {} -impl<'a, C, NC, A> EditApkUploadCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditApkUploadCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8337,7 +8333,7 @@ impl<'a, C, NC, A> EditApkUploadCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditApkUploadCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditApkUploadCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -8347,7 +8343,7 @@ impl<'a, C, NC, A> EditApkUploadCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditApkUploadCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditApkUploadCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -8358,7 +8354,7 @@ impl<'a, C, NC, A> EditApkUploadCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditApkUploadCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditApkUploadCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8379,7 +8375,7 @@ impl<'a, C, NC, A> EditApkUploadCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditApkUploadCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditApkUploadCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8396,7 +8392,7 @@ impl<'a, C, NC, A> EditApkUploadCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditApkUploadCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditApkUploadCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8440,10 +8436,10 @@ impl<'a, C, NC, A> EditApkUploadCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct EditApklistingUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditApklistingUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _request: ApkListing, _package_name: String, _edit_id: String, @@ -8454,9 +8450,9 @@ pub struct EditApklistingUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditApklistingUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditApklistingUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> EditApklistingUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditApklistingUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8598,7 +8594,7 @@ impl<'a, C, NC, A> EditApklistingUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ApkListing) -> EditApklistingUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ApkListing) -> EditApklistingUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8608,7 +8604,7 @@ impl<'a, C, NC, A> EditApklistingUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditApklistingUpdateCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditApklistingUpdateCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -8618,7 +8614,7 @@ impl<'a, C, NC, A> EditApklistingUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditApklistingUpdateCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditApklistingUpdateCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -8628,7 +8624,7 @@ impl<'a, C, NC, A> EditApklistingUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The APK version code whose APK-specific listings should be read or modified. - pub fn apk_version_code(mut self, new_value: i32) -> EditApklistingUpdateCall<'a, C, NC, A> { + pub fn apk_version_code(mut self, new_value: i32) -> EditApklistingUpdateCall<'a, C, A> { self._apk_version_code = new_value; self } @@ -8638,7 +8634,7 @@ impl<'a, C, NC, A> EditApklistingUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The language code (a BCP-47 language tag) of the APK-specific localized listing to read or modify. For example, to select Austrian German, pass "de-AT". - pub fn language(mut self, new_value: &str) -> EditApklistingUpdateCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> EditApklistingUpdateCall<'a, C, A> { self._language = new_value.to_string(); self } @@ -8649,7 +8645,7 @@ impl<'a, C, NC, A> EditApklistingUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditApklistingUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditApklistingUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8670,7 +8666,7 @@ impl<'a, C, NC, A> EditApklistingUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditApklistingUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditApklistingUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8687,7 +8683,7 @@ impl<'a, C, NC, A> EditApklistingUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditApklistingUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditApklistingUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8723,10 +8719,10 @@ impl<'a, C, NC, A> EditApklistingUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct EditApkListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditApkListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _delegate: Option<&'a mut Delegate>, @@ -8734,9 +8730,9 @@ pub struct EditApkListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditApkListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditApkListCall<'a, C, A> {} -impl<'a, C, NC, A> EditApkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditApkListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8869,7 +8865,7 @@ impl<'a, C, NC, A> EditApkListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditApkListCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditApkListCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -8879,7 +8875,7 @@ impl<'a, C, NC, A> EditApkListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditApkListCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditApkListCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -8890,7 +8886,7 @@ impl<'a, C, NC, A> EditApkListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditApkListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditApkListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8911,7 +8907,7 @@ impl<'a, C, NC, A> EditApkListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditApkListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditApkListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8928,7 +8924,7 @@ impl<'a, C, NC, A> EditApkListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditApkListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditApkListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8972,10 +8968,10 @@ impl<'a, C, NC, A> EditApkListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct EditApklistingPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditApklistingPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _request: ApkListing, _package_name: String, _edit_id: String, @@ -8986,9 +8982,9 @@ pub struct EditApklistingPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditApklistingPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditApklistingPatchCall<'a, C, A> {} -impl<'a, C, NC, A> EditApklistingPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditApklistingPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9130,7 +9126,7 @@ impl<'a, C, NC, A> EditApklistingPatchCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ApkListing) -> EditApklistingPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ApkListing) -> EditApklistingPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9140,7 +9136,7 @@ impl<'a, C, NC, A> EditApklistingPatchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditApklistingPatchCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditApklistingPatchCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -9150,7 +9146,7 @@ impl<'a, C, NC, A> EditApklistingPatchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditApklistingPatchCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditApklistingPatchCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -9160,7 +9156,7 @@ impl<'a, C, NC, A> EditApklistingPatchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The APK version code whose APK-specific listings should be read or modified. - pub fn apk_version_code(mut self, new_value: i32) -> EditApklistingPatchCall<'a, C, NC, A> { + pub fn apk_version_code(mut self, new_value: i32) -> EditApklistingPatchCall<'a, C, A> { self._apk_version_code = new_value; self } @@ -9170,7 +9166,7 @@ impl<'a, C, NC, A> EditApklistingPatchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The language code (a BCP-47 language tag) of the APK-specific localized listing to read or modify. For example, to select Austrian German, pass "de-AT". - pub fn language(mut self, new_value: &str) -> EditApklistingPatchCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> EditApklistingPatchCall<'a, C, A> { self._language = new_value.to_string(); self } @@ -9181,7 +9177,7 @@ impl<'a, C, NC, A> EditApklistingPatchCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditApklistingPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditApklistingPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9202,7 +9198,7 @@ impl<'a, C, NC, A> EditApklistingPatchCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditApklistingPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditApklistingPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9219,7 +9215,7 @@ impl<'a, C, NC, A> EditApklistingPatchCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditApklistingPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditApklistingPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9257,10 +9253,10 @@ impl<'a, C, NC, A> EditApklistingPatchCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct EditListingGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditListingGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _language: String, @@ -9269,9 +9265,9 @@ pub struct EditListingGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditListingGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditListingGetCall<'a, C, A> {} -impl<'a, C, NC, A> EditListingGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditListingGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9405,7 +9401,7 @@ impl<'a, C, NC, A> EditListingGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditListingGetCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditListingGetCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -9415,7 +9411,7 @@ impl<'a, C, NC, A> EditListingGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditListingGetCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditListingGetCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -9425,7 +9421,7 @@ impl<'a, C, NC, A> EditListingGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The language code (a BCP-47 language tag) of the localized listing to read or modify. For example, to select Austrian German, pass "de-AT". - pub fn language(mut self, new_value: &str) -> EditListingGetCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> EditListingGetCall<'a, C, A> { self._language = new_value.to_string(); self } @@ -9436,7 +9432,7 @@ impl<'a, C, NC, A> EditListingGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditListingGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditListingGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9457,7 +9453,7 @@ impl<'a, C, NC, A> EditListingGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditListingGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditListingGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9474,7 +9470,7 @@ impl<'a, C, NC, A> EditListingGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditListingGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditListingGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9510,10 +9506,10 @@ impl<'a, C, NC, A> EditListingGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct EditTesterGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditTesterGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _track: String, @@ -9522,9 +9518,9 @@ pub struct EditTesterGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditTesterGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditTesterGetCall<'a, C, A> {} -impl<'a, C, NC, A> EditTesterGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditTesterGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9658,7 +9654,7 @@ impl<'a, C, NC, A> EditTesterGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditTesterGetCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditTesterGetCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -9668,7 +9664,7 @@ impl<'a, C, NC, A> EditTesterGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditTesterGetCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditTesterGetCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -9677,7 +9673,7 @@ impl<'a, C, NC, A> EditTesterGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn track(mut self, new_value: &str) -> EditTesterGetCall<'a, C, NC, A> { + pub fn track(mut self, new_value: &str) -> EditTesterGetCall<'a, C, A> { self._track = new_value.to_string(); self } @@ -9688,7 +9684,7 @@ impl<'a, C, NC, A> EditTesterGetCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditTesterGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditTesterGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9709,7 +9705,7 @@ impl<'a, C, NC, A> EditTesterGetCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditTesterGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditTesterGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9726,7 +9722,7 @@ impl<'a, C, NC, A> EditTesterGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditTesterGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditTesterGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9764,10 +9760,10 @@ impl<'a, C, NC, A> EditTesterGetCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct EditDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _delegate: Option<&'a mut Delegate>, @@ -9775,9 +9771,9 @@ pub struct EditDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> EditDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9899,7 +9895,7 @@ impl<'a, C, NC, A> EditDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditDeleteCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditDeleteCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -9909,7 +9905,7 @@ impl<'a, C, NC, A> EditDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditDeleteCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditDeleteCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -9920,7 +9916,7 @@ impl<'a, C, NC, A> EditDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9941,7 +9937,7 @@ impl<'a, C, NC, A> EditDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9958,7 +9954,7 @@ impl<'a, C, NC, A> EditDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9997,10 +9993,10 @@ impl<'a, C, NC, A> EditDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .upload_resumable(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct EditExpansionfileUploadCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditExpansionfileUploadCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _apk_version_code: i32, @@ -10010,9 +10006,9 @@ pub struct EditExpansionfileUploadCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditExpansionfileUploadCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditExpansionfileUploadCall<'a, C, A> {} -impl<'a, C, NC, A> EditExpansionfileUploadCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditExpansionfileUploadCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10256,7 +10252,7 @@ impl<'a, C, NC, A> EditExpansionfileUploadCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditExpansionfileUploadCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditExpansionfileUploadCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -10266,7 +10262,7 @@ impl<'a, C, NC, A> EditExpansionfileUploadCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditExpansionfileUploadCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditExpansionfileUploadCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -10276,7 +10272,7 @@ impl<'a, C, NC, A> EditExpansionfileUploadCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The version code of the APK whose Expansion File configuration is being read or modified. - pub fn apk_version_code(mut self, new_value: i32) -> EditExpansionfileUploadCall<'a, C, NC, A> { + pub fn apk_version_code(mut self, new_value: i32) -> EditExpansionfileUploadCall<'a, C, A> { self._apk_version_code = new_value; self } @@ -10285,7 +10281,7 @@ impl<'a, C, NC, A> EditExpansionfileUploadCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn expansion_file_type(mut self, new_value: &str) -> EditExpansionfileUploadCall<'a, C, NC, A> { + pub fn expansion_file_type(mut self, new_value: &str) -> EditExpansionfileUploadCall<'a, C, A> { self._expansion_file_type = new_value.to_string(); self } @@ -10296,7 +10292,7 @@ impl<'a, C, NC, A> EditExpansionfileUploadCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditExpansionfileUploadCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditExpansionfileUploadCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10317,7 +10313,7 @@ impl<'a, C, NC, A> EditExpansionfileUploadCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditExpansionfileUploadCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditExpansionfileUploadCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10334,7 +10330,7 @@ impl<'a, C, NC, A> EditExpansionfileUploadCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditExpansionfileUploadCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditExpansionfileUploadCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10378,10 +10374,10 @@ impl<'a, C, NC, A> EditExpansionfileUploadCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct EditInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _request: AppEdit, _package_name: String, _delegate: Option<&'a mut Delegate>, @@ -10389,9 +10385,9 @@ pub struct EditInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditInsertCall<'a, C, A> {} -impl<'a, C, NC, A> EditInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10530,7 +10526,7 @@ impl<'a, C, NC, A> EditInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AppEdit) -> EditInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AppEdit) -> EditInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -10540,7 +10536,7 @@ impl<'a, C, NC, A> EditInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditInsertCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditInsertCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -10551,7 +10547,7 @@ impl<'a, C, NC, A> EditInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10572,7 +10568,7 @@ impl<'a, C, NC, A> EditInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10589,7 +10585,7 @@ impl<'a, C, NC, A> EditInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10627,10 +10623,10 @@ impl<'a, C, NC, A> EditInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct EditListingListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditListingListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _delegate: Option<&'a mut Delegate>, @@ -10638,9 +10634,9 @@ pub struct EditListingListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditListingListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditListingListCall<'a, C, A> {} -impl<'a, C, NC, A> EditListingListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditListingListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10773,7 +10769,7 @@ impl<'a, C, NC, A> EditListingListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditListingListCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditListingListCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -10783,7 +10779,7 @@ impl<'a, C, NC, A> EditListingListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditListingListCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditListingListCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -10794,7 +10790,7 @@ impl<'a, C, NC, A> EditListingListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditListingListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditListingListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10815,7 +10811,7 @@ impl<'a, C, NC, A> EditListingListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditListingListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditListingListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10832,7 +10828,7 @@ impl<'a, C, NC, A> EditListingListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditListingListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditListingListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10874,10 +10870,10 @@ impl<'a, C, NC, A> EditListingListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct EditTesterPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditTesterPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _request: Testers, _package_name: String, _edit_id: String, @@ -10887,9 +10883,9 @@ pub struct EditTesterPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditTesterPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditTesterPatchCall<'a, C, A> {} -impl<'a, C, NC, A> EditTesterPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditTesterPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11030,7 +11026,7 @@ impl<'a, C, NC, A> EditTesterPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Testers) -> EditTesterPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Testers) -> EditTesterPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -11040,7 +11036,7 @@ impl<'a, C, NC, A> EditTesterPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditTesterPatchCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditTesterPatchCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -11050,7 +11046,7 @@ impl<'a, C, NC, A> EditTesterPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditTesterPatchCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditTesterPatchCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -11059,7 +11055,7 @@ impl<'a, C, NC, A> EditTesterPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn track(mut self, new_value: &str) -> EditTesterPatchCall<'a, C, NC, A> { + pub fn track(mut self, new_value: &str) -> EditTesterPatchCall<'a, C, A> { self._track = new_value.to_string(); self } @@ -11070,7 +11066,7 @@ impl<'a, C, NC, A> EditTesterPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditTesterPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditTesterPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11091,7 +11087,7 @@ impl<'a, C, NC, A> EditTesterPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditTesterPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditTesterPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11108,7 +11104,7 @@ impl<'a, C, NC, A> EditTesterPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditTesterPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditTesterPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11146,10 +11142,10 @@ impl<'a, C, NC, A> EditTesterPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct EditCommitCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditCommitCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _delegate: Option<&'a mut Delegate>, @@ -11157,9 +11153,9 @@ pub struct EditCommitCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditCommitCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditCommitCall<'a, C, A> {} -impl<'a, C, NC, A> EditCommitCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditCommitCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11292,7 +11288,7 @@ impl<'a, C, NC, A> EditCommitCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditCommitCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditCommitCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -11302,7 +11298,7 @@ impl<'a, C, NC, A> EditCommitCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditCommitCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditCommitCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -11313,7 +11309,7 @@ impl<'a, C, NC, A> EditCommitCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditCommitCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditCommitCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11334,7 +11330,7 @@ impl<'a, C, NC, A> EditCommitCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditCommitCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditCommitCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11351,7 +11347,7 @@ impl<'a, C, NC, A> EditCommitCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditCommitCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditCommitCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11389,10 +11385,10 @@ impl<'a, C, NC, A> EditCommitCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct EditTrackListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditTrackListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _delegate: Option<&'a mut Delegate>, @@ -11400,9 +11396,9 @@ pub struct EditTrackListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditTrackListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditTrackListCall<'a, C, A> {} -impl<'a, C, NC, A> EditTrackListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditTrackListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11535,7 +11531,7 @@ impl<'a, C, NC, A> EditTrackListCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditTrackListCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditTrackListCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -11545,7 +11541,7 @@ impl<'a, C, NC, A> EditTrackListCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditTrackListCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditTrackListCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -11556,7 +11552,7 @@ impl<'a, C, NC, A> EditTrackListCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditTrackListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditTrackListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11577,7 +11573,7 @@ impl<'a, C, NC, A> EditTrackListCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditTrackListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditTrackListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11594,7 +11590,7 @@ impl<'a, C, NC, A> EditTrackListCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditTrackListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditTrackListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11632,10 +11628,10 @@ impl<'a, C, NC, A> EditTrackListCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct EditValidateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditValidateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _delegate: Option<&'a mut Delegate>, @@ -11643,9 +11639,9 @@ pub struct EditValidateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditValidateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditValidateCall<'a, C, A> {} -impl<'a, C, NC, A> EditValidateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditValidateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11778,7 +11774,7 @@ impl<'a, C, NC, A> EditValidateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditValidateCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditValidateCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -11788,7 +11784,7 @@ impl<'a, C, NC, A> EditValidateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditValidateCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditValidateCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -11799,7 +11795,7 @@ impl<'a, C, NC, A> EditValidateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditValidateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditValidateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11820,7 +11816,7 @@ impl<'a, C, NC, A> EditValidateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditValidateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditValidateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11837,7 +11833,7 @@ impl<'a, C, NC, A> EditValidateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditValidateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditValidateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11881,10 +11877,10 @@ impl<'a, C, NC, A> EditValidateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct EditListingUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditListingUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _request: Listing, _package_name: String, _edit_id: String, @@ -11894,9 +11890,9 @@ pub struct EditListingUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditListingUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditListingUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> EditListingUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditListingUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12037,7 +12033,7 @@ impl<'a, C, NC, A> EditListingUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Listing) -> EditListingUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Listing) -> EditListingUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -12047,7 +12043,7 @@ impl<'a, C, NC, A> EditListingUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditListingUpdateCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditListingUpdateCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -12057,7 +12053,7 @@ impl<'a, C, NC, A> EditListingUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditListingUpdateCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditListingUpdateCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -12067,7 +12063,7 @@ impl<'a, C, NC, A> EditListingUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The language code (a BCP-47 language tag) of the localized listing to read or modify. For example, to select Austrian German, pass "de-AT". - pub fn language(mut self, new_value: &str) -> EditListingUpdateCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> EditListingUpdateCall<'a, C, A> { self._language = new_value.to_string(); self } @@ -12078,7 +12074,7 @@ impl<'a, C, NC, A> EditListingUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditListingUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditListingUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12099,7 +12095,7 @@ impl<'a, C, NC, A> EditListingUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditListingUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditListingUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12116,7 +12112,7 @@ impl<'a, C, NC, A> EditListingUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditListingUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditListingUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12154,10 +12150,10 @@ impl<'a, C, NC, A> EditListingUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct EditExpansionfileGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditExpansionfileGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _apk_version_code: i32, @@ -12167,9 +12163,9 @@ pub struct EditExpansionfileGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditExpansionfileGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditExpansionfileGetCall<'a, C, A> {} -impl<'a, C, NC, A> EditExpansionfileGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditExpansionfileGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12304,7 +12300,7 @@ impl<'a, C, NC, A> EditExpansionfileGetCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditExpansionfileGetCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditExpansionfileGetCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -12314,7 +12310,7 @@ impl<'a, C, NC, A> EditExpansionfileGetCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditExpansionfileGetCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditExpansionfileGetCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -12324,7 +12320,7 @@ impl<'a, C, NC, A> EditExpansionfileGetCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The version code of the APK whose Expansion File configuration is being read or modified. - pub fn apk_version_code(mut self, new_value: i32) -> EditExpansionfileGetCall<'a, C, NC, A> { + pub fn apk_version_code(mut self, new_value: i32) -> EditExpansionfileGetCall<'a, C, A> { self._apk_version_code = new_value; self } @@ -12333,7 +12329,7 @@ impl<'a, C, NC, A> EditExpansionfileGetCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn expansion_file_type(mut self, new_value: &str) -> EditExpansionfileGetCall<'a, C, NC, A> { + pub fn expansion_file_type(mut self, new_value: &str) -> EditExpansionfileGetCall<'a, C, A> { self._expansion_file_type = new_value.to_string(); self } @@ -12344,7 +12340,7 @@ impl<'a, C, NC, A> EditExpansionfileGetCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditExpansionfileGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditExpansionfileGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12365,7 +12361,7 @@ impl<'a, C, NC, A> EditExpansionfileGetCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditExpansionfileGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditExpansionfileGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12382,7 +12378,7 @@ impl<'a, C, NC, A> EditExpansionfileGetCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditExpansionfileGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditExpansionfileGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12420,10 +12416,10 @@ impl<'a, C, NC, A> EditExpansionfileGetCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct EditImageDeleteallCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditImageDeleteallCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _language: String, @@ -12433,9 +12429,9 @@ pub struct EditImageDeleteallCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditImageDeleteallCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditImageDeleteallCall<'a, C, A> {} -impl<'a, C, NC, A> EditImageDeleteallCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditImageDeleteallCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12570,7 +12566,7 @@ impl<'a, C, NC, A> EditImageDeleteallCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditImageDeleteallCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditImageDeleteallCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -12580,7 +12576,7 @@ impl<'a, C, NC, A> EditImageDeleteallCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditImageDeleteallCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditImageDeleteallCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -12590,7 +12586,7 @@ impl<'a, C, NC, A> EditImageDeleteallCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The language code (a BCP-47 language tag) of the localized listing whose images are to read or modified. For example, to select Austrian German, pass "de-AT". - pub fn language(mut self, new_value: &str) -> EditImageDeleteallCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> EditImageDeleteallCall<'a, C, A> { self._language = new_value.to_string(); self } @@ -12599,7 +12595,7 @@ impl<'a, C, NC, A> EditImageDeleteallCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn image_type(mut self, new_value: &str) -> EditImageDeleteallCall<'a, C, NC, A> { + pub fn image_type(mut self, new_value: &str) -> EditImageDeleteallCall<'a, C, A> { self._image_type = new_value.to_string(); self } @@ -12610,7 +12606,7 @@ impl<'a, C, NC, A> EditImageDeleteallCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditImageDeleteallCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditImageDeleteallCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12631,7 +12627,7 @@ impl<'a, C, NC, A> EditImageDeleteallCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditImageDeleteallCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditImageDeleteallCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12648,7 +12644,7 @@ impl<'a, C, NC, A> EditImageDeleteallCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditImageDeleteallCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditImageDeleteallCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12692,10 +12688,10 @@ impl<'a, C, NC, A> EditImageDeleteallCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct EditDetailPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditDetailPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _request: AppDetails, _package_name: String, _edit_id: String, @@ -12704,9 +12700,9 @@ pub struct EditDetailPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditDetailPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditDetailPatchCall<'a, C, A> {} -impl<'a, C, NC, A> EditDetailPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditDetailPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12846,7 +12842,7 @@ impl<'a, C, NC, A> EditDetailPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AppDetails) -> EditDetailPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AppDetails) -> EditDetailPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -12856,7 +12852,7 @@ impl<'a, C, NC, A> EditDetailPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditDetailPatchCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditDetailPatchCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -12866,7 +12862,7 @@ impl<'a, C, NC, A> EditDetailPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditDetailPatchCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditDetailPatchCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -12877,7 +12873,7 @@ impl<'a, C, NC, A> EditDetailPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditDetailPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditDetailPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12898,7 +12894,7 @@ impl<'a, C, NC, A> EditDetailPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditDetailPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditDetailPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12915,7 +12911,7 @@ impl<'a, C, NC, A> EditDetailPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditDetailPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditDetailPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12959,10 +12955,10 @@ impl<'a, C, NC, A> EditDetailPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct EditTrackPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditTrackPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _request: Track, _package_name: String, _edit_id: String, @@ -12972,9 +12968,9 @@ pub struct EditTrackPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditTrackPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditTrackPatchCall<'a, C, A> {} -impl<'a, C, NC, A> EditTrackPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditTrackPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13115,7 +13111,7 @@ impl<'a, C, NC, A> EditTrackPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Track) -> EditTrackPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Track) -> EditTrackPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13125,7 +13121,7 @@ impl<'a, C, NC, A> EditTrackPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditTrackPatchCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditTrackPatchCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -13135,7 +13131,7 @@ impl<'a, C, NC, A> EditTrackPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditTrackPatchCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditTrackPatchCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -13145,7 +13141,7 @@ impl<'a, C, NC, A> EditTrackPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The track type to read or modify. - pub fn track(mut self, new_value: &str) -> EditTrackPatchCall<'a, C, NC, A> { + pub fn track(mut self, new_value: &str) -> EditTrackPatchCall<'a, C, A> { self._track = new_value.to_string(); self } @@ -13156,7 +13152,7 @@ impl<'a, C, NC, A> EditTrackPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditTrackPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditTrackPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13177,7 +13173,7 @@ impl<'a, C, NC, A> EditTrackPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditTrackPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditTrackPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13194,7 +13190,7 @@ impl<'a, C, NC, A> EditTrackPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditTrackPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditTrackPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13232,10 +13228,10 @@ impl<'a, C, NC, A> EditTrackPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct EditListingDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditListingDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _language: String, @@ -13244,9 +13240,9 @@ pub struct EditListingDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditListingDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditListingDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> EditListingDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditListingDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13369,7 +13365,7 @@ impl<'a, C, NC, A> EditListingDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditListingDeleteCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditListingDeleteCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -13379,7 +13375,7 @@ impl<'a, C, NC, A> EditListingDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditListingDeleteCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditListingDeleteCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -13389,7 +13385,7 @@ impl<'a, C, NC, A> EditListingDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The language code (a BCP-47 language tag) of the localized listing to read or modify. For example, to select Austrian German, pass "de-AT". - pub fn language(mut self, new_value: &str) -> EditListingDeleteCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> EditListingDeleteCall<'a, C, A> { self._language = new_value.to_string(); self } @@ -13400,7 +13396,7 @@ impl<'a, C, NC, A> EditListingDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditListingDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditListingDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13421,7 +13417,7 @@ impl<'a, C, NC, A> EditListingDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditListingDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditListingDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13438,7 +13434,7 @@ impl<'a, C, NC, A> EditListingDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditListingDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditListingDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13476,10 +13472,10 @@ impl<'a, C, NC, A> EditListingDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct EditApklistingGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditApklistingGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _apk_version_code: i32, @@ -13489,9 +13485,9 @@ pub struct EditApklistingGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditApklistingGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditApklistingGetCall<'a, C, A> {} -impl<'a, C, NC, A> EditApklistingGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditApklistingGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13626,7 +13622,7 @@ impl<'a, C, NC, A> EditApklistingGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditApklistingGetCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditApklistingGetCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -13636,7 +13632,7 @@ impl<'a, C, NC, A> EditApklistingGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditApklistingGetCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditApklistingGetCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -13646,7 +13642,7 @@ impl<'a, C, NC, A> EditApklistingGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The APK version code whose APK-specific listings should be read or modified. - pub fn apk_version_code(mut self, new_value: i32) -> EditApklistingGetCall<'a, C, NC, A> { + pub fn apk_version_code(mut self, new_value: i32) -> EditApklistingGetCall<'a, C, A> { self._apk_version_code = new_value; self } @@ -13656,7 +13652,7 @@ impl<'a, C, NC, A> EditApklistingGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The language code (a BCP-47 language tag) of the APK-specific localized listing to read or modify. For example, to select Austrian German, pass "de-AT". - pub fn language(mut self, new_value: &str) -> EditApklistingGetCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> EditApklistingGetCall<'a, C, A> { self._language = new_value.to_string(); self } @@ -13667,7 +13663,7 @@ impl<'a, C, NC, A> EditApklistingGetCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditApklistingGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditApklistingGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13688,7 +13684,7 @@ impl<'a, C, NC, A> EditApklistingGetCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditApklistingGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditApklistingGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13705,7 +13701,7 @@ impl<'a, C, NC, A> EditApklistingGetCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditApklistingGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditApklistingGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13747,10 +13743,10 @@ impl<'a, C, NC, A> EditApklistingGetCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct EditTesterUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditTesterUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _request: Testers, _package_name: String, _edit_id: String, @@ -13760,9 +13756,9 @@ pub struct EditTesterUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditTesterUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditTesterUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> EditTesterUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditTesterUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13903,7 +13899,7 @@ impl<'a, C, NC, A> EditTesterUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Testers) -> EditTesterUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Testers) -> EditTesterUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13913,7 +13909,7 @@ impl<'a, C, NC, A> EditTesterUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditTesterUpdateCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditTesterUpdateCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -13923,7 +13919,7 @@ impl<'a, C, NC, A> EditTesterUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditTesterUpdateCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditTesterUpdateCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -13932,7 +13928,7 @@ impl<'a, C, NC, A> EditTesterUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn track(mut self, new_value: &str) -> EditTesterUpdateCall<'a, C, NC, A> { + pub fn track(mut self, new_value: &str) -> EditTesterUpdateCall<'a, C, A> { self._track = new_value.to_string(); self } @@ -13943,7 +13939,7 @@ impl<'a, C, NC, A> EditTesterUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditTesterUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditTesterUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13964,7 +13960,7 @@ impl<'a, C, NC, A> EditTesterUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditTesterUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditTesterUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13981,7 +13977,7 @@ impl<'a, C, NC, A> EditTesterUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditTesterUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditTesterUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14019,10 +14015,10 @@ impl<'a, C, NC, A> EditTesterUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct EditApklistingListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EditApklistingListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _edit_id: String, _apk_version_code: i32, @@ -14031,9 +14027,9 @@ pub struct EditApklistingListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EditApklistingListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EditApklistingListCall<'a, C, A> {} -impl<'a, C, NC, A> EditApklistingListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EditApklistingListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14167,7 +14163,7 @@ impl<'a, C, NC, A> EditApklistingListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Unique identifier for the Android app that is being updated; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> EditApklistingListCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> EditApklistingListCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -14177,7 +14173,7 @@ impl<'a, C, NC, A> EditApklistingListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Unique identifier for this edit. - pub fn edit_id(mut self, new_value: &str) -> EditApklistingListCall<'a, C, NC, A> { + pub fn edit_id(mut self, new_value: &str) -> EditApklistingListCall<'a, C, A> { self._edit_id = new_value.to_string(); self } @@ -14187,7 +14183,7 @@ impl<'a, C, NC, A> EditApklistingListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The APK version code whose APK-specific listings should be read or modified. - pub fn apk_version_code(mut self, new_value: i32) -> EditApklistingListCall<'a, C, NC, A> { + pub fn apk_version_code(mut self, new_value: i32) -> EditApklistingListCall<'a, C, A> { self._apk_version_code = new_value; self } @@ -14198,7 +14194,7 @@ impl<'a, C, NC, A> EditApklistingListCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditApklistingListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EditApklistingListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14219,7 +14215,7 @@ impl<'a, C, NC, A> EditApklistingListCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EditApklistingListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EditApklistingListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14236,7 +14232,7 @@ impl<'a, C, NC, A> EditApklistingListCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EditApklistingListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EditApklistingListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14278,19 +14274,19 @@ impl<'a, C, NC, A> EditApklistingListCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct InappproductBatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InappproductBatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _request: InappproductsBatchRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InappproductBatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InappproductBatchCall<'a, C, A> {} -impl<'a, C, NC, A> InappproductBatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InappproductBatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14404,7 +14400,7 @@ impl<'a, C, NC, A> InappproductBatchCall<'a, C, NC, A> where NC: hyper::net::Net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &InappproductsBatchRequest) -> InappproductBatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &InappproductsBatchRequest) -> InappproductBatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -14415,7 +14411,7 @@ impl<'a, C, NC, A> InappproductBatchCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InappproductBatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InappproductBatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14436,7 +14432,7 @@ impl<'a, C, NC, A> InappproductBatchCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InappproductBatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InappproductBatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14453,7 +14449,7 @@ impl<'a, C, NC, A> InappproductBatchCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InappproductBatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InappproductBatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14494,10 +14490,10 @@ impl<'a, C, NC, A> InappproductBatchCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct InappproductListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InappproductListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _token: Option, _start_index: Option, @@ -14507,9 +14503,9 @@ pub struct InappproductListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InappproductListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InappproductListCall<'a, C, A> {} -impl<'a, C, NC, A> InappproductListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InappproductListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14650,28 +14646,28 @@ impl<'a, C, NC, A> InappproductListCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Unique identifier for the Android app with in-app products; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> InappproductListCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> InappproductListCall<'a, C, A> { self._package_name = new_value.to_string(); self } /// Sets the *token* query property to the given value. /// /// - pub fn token(mut self, new_value: &str) -> InappproductListCall<'a, C, NC, A> { + pub fn token(mut self, new_value: &str) -> InappproductListCall<'a, C, A> { self._token = Some(new_value.to_string()); self } /// Sets the *start index* query property to the given value. /// /// - pub fn start_index(mut self, new_value: u32) -> InappproductListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: u32) -> InappproductListCall<'a, C, A> { self._start_index = Some(new_value); self } /// Sets the *max results* query property to the given value. /// /// - pub fn max_results(mut self, new_value: u32) -> InappproductListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> InappproductListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -14682,7 +14678,7 @@ impl<'a, C, NC, A> InappproductListCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InappproductListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InappproductListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14703,7 +14699,7 @@ impl<'a, C, NC, A> InappproductListCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InappproductListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InappproductListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14720,7 +14716,7 @@ impl<'a, C, NC, A> InappproductListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InappproductListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InappproductListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14765,10 +14761,10 @@ impl<'a, C, NC, A> InappproductListCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct InappproductInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InappproductInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _request: InAppProduct, _package_name: String, _auto_convert_missing_prices: Option, @@ -14777,9 +14773,9 @@ pub struct InappproductInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InappproductInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InappproductInsertCall<'a, C, A> {} -impl<'a, C, NC, A> InappproductInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InappproductInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14921,7 +14917,7 @@ impl<'a, C, NC, A> InappproductInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &InAppProduct) -> InappproductInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &InAppProduct) -> InappproductInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -14931,7 +14927,7 @@ impl<'a, C, NC, A> InappproductInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Unique identifier for the Android app; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> InappproductInsertCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> InappproductInsertCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -14939,7 +14935,7 @@ impl<'a, C, NC, A> InappproductInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// If true the prices for all regions targeted by the parent app that don't have a price specified for this in-app product will be auto converted to the target currency based on the default price. Defaults to false. - pub fn auto_convert_missing_prices(mut self, new_value: bool) -> InappproductInsertCall<'a, C, NC, A> { + pub fn auto_convert_missing_prices(mut self, new_value: bool) -> InappproductInsertCall<'a, C, A> { self._auto_convert_missing_prices = Some(new_value); self } @@ -14950,7 +14946,7 @@ impl<'a, C, NC, A> InappproductInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InappproductInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InappproductInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14971,7 +14967,7 @@ impl<'a, C, NC, A> InappproductInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InappproductInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InappproductInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14988,7 +14984,7 @@ impl<'a, C, NC, A> InappproductInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InappproductInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InappproductInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15026,10 +15022,10 @@ impl<'a, C, NC, A> InappproductInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct InappproductDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InappproductDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _sku: String, _delegate: Option<&'a mut Delegate>, @@ -15037,9 +15033,9 @@ pub struct InappproductDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InappproductDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InappproductDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> InappproductDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InappproductDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15161,7 +15157,7 @@ impl<'a, C, NC, A> InappproductDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Unique identifier for the Android app with the in-app product; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> InappproductDeleteCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> InappproductDeleteCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -15171,7 +15167,7 @@ impl<'a, C, NC, A> InappproductDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Unique identifier for the in-app product. - pub fn sku(mut self, new_value: &str) -> InappproductDeleteCall<'a, C, NC, A> { + pub fn sku(mut self, new_value: &str) -> InappproductDeleteCall<'a, C, A> { self._sku = new_value.to_string(); self } @@ -15182,7 +15178,7 @@ impl<'a, C, NC, A> InappproductDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InappproductDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InappproductDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15203,7 +15199,7 @@ impl<'a, C, NC, A> InappproductDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InappproductDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InappproductDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15220,7 +15216,7 @@ impl<'a, C, NC, A> InappproductDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InappproductDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InappproductDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15258,10 +15254,10 @@ impl<'a, C, NC, A> InappproductDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct InappproductGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InappproductGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _package_name: String, _sku: String, _delegate: Option<&'a mut Delegate>, @@ -15269,9 +15265,9 @@ pub struct InappproductGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InappproductGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InappproductGetCall<'a, C, A> {} -impl<'a, C, NC, A> InappproductGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InappproductGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15403,7 +15399,7 @@ impl<'a, C, NC, A> InappproductGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn package_name(mut self, new_value: &str) -> InappproductGetCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> InappproductGetCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -15413,7 +15409,7 @@ impl<'a, C, NC, A> InappproductGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Unique identifier for the in-app product. - pub fn sku(mut self, new_value: &str) -> InappproductGetCall<'a, C, NC, A> { + pub fn sku(mut self, new_value: &str) -> InappproductGetCall<'a, C, A> { self._sku = new_value.to_string(); self } @@ -15424,7 +15420,7 @@ impl<'a, C, NC, A> InappproductGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InappproductGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InappproductGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15445,7 +15441,7 @@ impl<'a, C, NC, A> InappproductGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InappproductGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InappproductGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15462,7 +15458,7 @@ impl<'a, C, NC, A> InappproductGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InappproductGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InappproductGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15507,10 +15503,10 @@ impl<'a, C, NC, A> InappproductGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct InappproductUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InappproductUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _request: InAppProduct, _package_name: String, _sku: String, @@ -15520,9 +15516,9 @@ pub struct InappproductUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InappproductUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InappproductUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> InappproductUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InappproductUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15665,7 +15661,7 @@ impl<'a, C, NC, A> InappproductUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &InAppProduct) -> InappproductUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &InAppProduct) -> InappproductUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -15675,7 +15671,7 @@ impl<'a, C, NC, A> InappproductUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Unique identifier for the Android app with the in-app product; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> InappproductUpdateCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> InappproductUpdateCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -15685,7 +15681,7 @@ impl<'a, C, NC, A> InappproductUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Unique identifier for the in-app product. - pub fn sku(mut self, new_value: &str) -> InappproductUpdateCall<'a, C, NC, A> { + pub fn sku(mut self, new_value: &str) -> InappproductUpdateCall<'a, C, A> { self._sku = new_value.to_string(); self } @@ -15693,7 +15689,7 @@ impl<'a, C, NC, A> InappproductUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// If true the prices for all regions targeted by the parent app that don't have a price specified for this in-app product will be auto converted to the target currency based on the default price. Defaults to false. - pub fn auto_convert_missing_prices(mut self, new_value: bool) -> InappproductUpdateCall<'a, C, NC, A> { + pub fn auto_convert_missing_prices(mut self, new_value: bool) -> InappproductUpdateCall<'a, C, A> { self._auto_convert_missing_prices = Some(new_value); self } @@ -15704,7 +15700,7 @@ impl<'a, C, NC, A> InappproductUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InappproductUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InappproductUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15725,7 +15721,7 @@ impl<'a, C, NC, A> InappproductUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InappproductUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InappproductUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15742,7 +15738,7 @@ impl<'a, C, NC, A> InappproductUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InappproductUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InappproductUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15787,10 +15783,10 @@ impl<'a, C, NC, A> InappproductUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct InappproductPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InappproductPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AndroidPublisher, + hub: &'a AndroidPublisher, _request: InAppProduct, _package_name: String, _sku: String, @@ -15800,9 +15796,9 @@ pub struct InappproductPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InappproductPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InappproductPatchCall<'a, C, A> {} -impl<'a, C, NC, A> InappproductPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InappproductPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15945,7 +15941,7 @@ impl<'a, C, NC, A> InappproductPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &InAppProduct) -> InappproductPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &InAppProduct) -> InappproductPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -15955,7 +15951,7 @@ impl<'a, C, NC, A> InappproductPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Unique identifier for the Android app with the in-app product; for example, "com.spiffygame". - pub fn package_name(mut self, new_value: &str) -> InappproductPatchCall<'a, C, NC, A> { + pub fn package_name(mut self, new_value: &str) -> InappproductPatchCall<'a, C, A> { self._package_name = new_value.to_string(); self } @@ -15965,7 +15961,7 @@ impl<'a, C, NC, A> InappproductPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Unique identifier for the in-app product. - pub fn sku(mut self, new_value: &str) -> InappproductPatchCall<'a, C, NC, A> { + pub fn sku(mut self, new_value: &str) -> InappproductPatchCall<'a, C, A> { self._sku = new_value.to_string(); self } @@ -15973,7 +15969,7 @@ impl<'a, C, NC, A> InappproductPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// If true the prices for all regions targeted by the parent app that don't have a price specified for this in-app product will be auto converted to the target currency based on the default price. Defaults to false. - pub fn auto_convert_missing_prices(mut self, new_value: bool) -> InappproductPatchCall<'a, C, NC, A> { + pub fn auto_convert_missing_prices(mut self, new_value: bool) -> InappproductPatchCall<'a, C, A> { self._auto_convert_missing_prices = Some(new_value); self } @@ -15984,7 +15980,7 @@ impl<'a, C, NC, A> InappproductPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InappproductPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InappproductPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16005,7 +16001,7 @@ impl<'a, C, NC, A> InappproductPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InappproductPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InappproductPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16022,7 +16018,7 @@ impl<'a, C, NC, A> InappproductPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InappproductPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InappproductPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/appsactivity1/Cargo.toml b/gen/appsactivity1/Cargo.toml index beef1d3722b..1eac69cbd88 100644 --- a/gen/appsactivity1/Cargo.toml +++ b/gen/appsactivity1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-appsactivity1" -version = "0.1.4+20140828" +version = "0.1.5+20140828" authors = ["Sebastian Thiel "] description = "A complete library to interact with appsactivity (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/appsactivity1" homepage = "https://developers.google.com/google-apps/activity/" -documentation = "http://byron.github.io/google-apis-rs/google-appsactivity1" +documentation = "http://byron.github.io/google-apis-rs/google_appsactivity1" license = "MIT" keywords = ["appsactivity", "google", "protocol", "web", "api"] diff --git a/gen/appsactivity1/README.md b/gen/appsactivity1/README.md index 472dcde0dbd..eb769f9ab33 100644 --- a/gen/appsactivity1/README.md +++ b/gen/appsactivity1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-appsactivity1` library allows access to all features of the *Google appsactivity* service. -This documentation was generated from *appsactivity* crate version *0.1.4+20140828*, where *20140828* is the exact revision of the *appsactivity:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *appsactivity* crate version *0.1.5+20140828*, where *20140828* is the exact revision of the *appsactivity:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *appsactivity* *v1* API can be found at the [official documentation site](https://developers.google.com/google-apps/activity/). diff --git a/gen/appsactivity1/src/cmn.rs b/gen/appsactivity1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/appsactivity1/src/cmn.rs +++ b/gen/appsactivity1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/appsactivity1/src/lib.rs b/gen/appsactivity1/src/lib.rs index d331faf548b..70150be9f7d 100644 --- a/gen/appsactivity1/src/lib.rs +++ b/gen/appsactivity1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *appsactivity* crate version *0.1.4+20140828*, where *20140828* is the exact revision of the *appsactivity:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *appsactivity* crate version *0.1.5+20140828*, where *20140828* is the exact revision of the *appsactivity:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *appsactivity* *v1* API can be found at the //! [official documentation site](https://developers.google.com/google-apps/activity/). @@ -195,7 +195,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -305,34 +304,31 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Appsactivity { +pub struct Appsactivity { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Appsactivity {} +impl<'a, C, A> Hub for Appsactivity {} -impl<'a, C, NC, A> Appsactivity - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Appsactivity + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Appsactivity { + pub fn new(client: C, authenticator: A) -> Appsactivity { Appsactivity { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn activities(&'a self) -> ActivityMethods<'a, C, NC, A> { + pub fn activities(&'a self) -> ActivityMethods<'a, C, A> { ActivityMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -593,20 +589,20 @@ impl Part for Event {} /// let rb = hub.activities(); /// # } /// ``` -pub struct ActivityMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ActivityMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Appsactivity, + hub: &'a Appsactivity, } -impl<'a, C, NC, A> MethodsBuilder for ActivityMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ActivityMethods<'a, C, A> {} -impl<'a, C, NC, A> ActivityMethods<'a, C, NC, A> { +impl<'a, C, A> ActivityMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Returns a list of activities visible to the current logged in user. Visible activities are determined by the visiblity settings of the object that was acted on, e.g. Drive files a user can see. An activity is a record of past events. Multiple events may be merged if they are similar. A request is scoped to activities from a given Google service using the source parameter. - pub fn list(&self) -> ActivityListCall<'a, C, NC, A> { + pub fn list(&self) -> ActivityListCall<'a, C, A> { ActivityListCall { hub: self.hub, _user_id: Default::default(), @@ -668,10 +664,10 @@ impl<'a, C, NC, A> ActivityMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct ActivityListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ActivityListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Appsactivity, + hub: &'a Appsactivity, _user_id: Option, _source: Option, _page_token: Option, @@ -684,9 +680,9 @@ pub struct ActivityListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ActivityListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ActivityListCall<'a, C, A> {} -impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ActivityListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -812,7 +808,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Indicates the user to return activity for. Use the special value me to indicate the currently authenticated user. - pub fn user_id(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._user_id = Some(new_value.to_string()); self } @@ -821,7 +817,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// The Google service from which to return activities. Possible values of source are: /// - drive.google.com - pub fn source(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -829,7 +825,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// A token to retrieve a specific page of results. - pub fn page_token(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -837,7 +833,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The maximum number of events to return on a page. The response includes a continuation token if there are more events. - pub fn page_size(mut self, new_value: i32) -> ActivityListCall<'a, C, NC, A> { + pub fn page_size(mut self, new_value: i32) -> ActivityListCall<'a, C, A> { self._page_size = Some(new_value); self } @@ -845,7 +841,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Indicates the strategy to use when grouping singleEvents items in the associated combinedEvent object. - pub fn grouping_strategy(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn grouping_strategy(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._grouping_strategy = Some(new_value.to_string()); self } @@ -853,7 +849,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Identifies the Drive item to return activities for. - pub fn drive_file_id(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn drive_file_id(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._drive_file_id = Some(new_value.to_string()); self } @@ -861,7 +857,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Identifies the Drive folder containing the items for which to return activities. - pub fn drive_ancestor_id(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn drive_ancestor_id(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._drive_ancestor_id = Some(new_value.to_string()); self } @@ -872,7 +868,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivityListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivityListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -893,7 +889,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ActivityListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ActivityListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -910,7 +906,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ActivityListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ActivityListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/appstate1/Cargo.toml b/gen/appstate1/Cargo.toml index 12f3b0125f2..939c0ce59ab 100644 --- a/gen/appstate1/Cargo.toml +++ b/gen/appstate1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-appstate1" -version = "0.1.4+20150326" +version = "0.1.5+20150326" authors = ["Sebastian Thiel "] description = "A complete library to interact with App State (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/appstate1" homepage = "https://developers.google.com/games/services/web/api/states" -documentation = "http://byron.github.io/google-apis-rs/google-appstate1" +documentation = "http://byron.github.io/google-apis-rs/google_appstate1" license = "MIT" keywords = ["appstate", "google", "protocol", "web", "api"] diff --git a/gen/appstate1/README.md b/gen/appstate1/README.md index f23e40904f9..0b6ae78a323 100644 --- a/gen/appstate1/README.md +++ b/gen/appstate1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-appstate1` library allows access to all features of the *Google App State* service. -This documentation was generated from *App State* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *appstate:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *App State* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *appstate:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *App State* *v1* API can be found at the [official documentation site](https://developers.google.com/games/services/web/api/states). diff --git a/gen/appstate1/src/cmn.rs b/gen/appstate1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/appstate1/src/cmn.rs +++ b/gen/appstate1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/appstate1/src/lib.rs b/gen/appstate1/src/lib.rs index 6c30216f59c..8dca5708fcf 100644 --- a/gen/appstate1/src/lib.rs +++ b/gen/appstate1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *App State* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *appstate:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *App State* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *appstate:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *App State* *v1* API can be found at the //! [official documentation site](https://developers.google.com/games/services/web/api/states). @@ -196,7 +196,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -294,34 +293,31 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct AppState { +pub struct AppState { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for AppState {} +impl<'a, C, A> Hub for AppState {} -impl<'a, C, NC, A> AppState - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AppState + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> AppState { + pub fn new(client: C, authenticator: A) -> AppState { AppState { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn states(&'a self) -> StateMethods<'a, C, NC, A> { + pub fn states(&'a self) -> StateMethods<'a, C, A> { StateMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -462,15 +458,15 @@ impl ResponseResult for WriteResult {} /// let rb = hub.states(); /// # } /// ``` -pub struct StateMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct StateMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AppState, + hub: &'a AppState, } -impl<'a, C, NC, A> MethodsBuilder for StateMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for StateMethods<'a, C, A> {} -impl<'a, C, NC, A> StateMethods<'a, C, NC, A> { +impl<'a, C, A> StateMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -479,7 +475,7 @@ impl<'a, C, NC, A> StateMethods<'a, C, NC, A> { /// # Arguments /// /// * `stateKey` - The key for the data to be retrieved. - pub fn delete(&self, state_key: i32) -> StateDeleteCall<'a, C, NC, A> { + pub fn delete(&self, state_key: i32) -> StateDeleteCall<'a, C, A> { StateDeleteCall { hub: self.hub, _state_key: state_key, @@ -496,7 +492,7 @@ impl<'a, C, NC, A> StateMethods<'a, C, NC, A> { /// # Arguments /// /// * `stateKey` - The key for the data to be retrieved. - pub fn get(&self, state_key: i32) -> StateGetCall<'a, C, NC, A> { + pub fn get(&self, state_key: i32) -> StateGetCall<'a, C, A> { StateGetCall { hub: self.hub, _state_key: state_key, @@ -513,7 +509,7 @@ impl<'a, C, NC, A> StateMethods<'a, C, NC, A> { /// # Arguments /// /// * `stateKey` - The key for the data to be retrieved. - pub fn clear(&self, state_key: i32) -> StateClearCall<'a, C, NC, A> { + pub fn clear(&self, state_key: i32) -> StateClearCall<'a, C, A> { StateClearCall { hub: self.hub, _state_key: state_key, @@ -527,7 +523,7 @@ impl<'a, C, NC, A> StateMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Lists all the states keys, and optionally the state data. - pub fn list(&self) -> StateListCall<'a, C, NC, A> { + pub fn list(&self) -> StateListCall<'a, C, A> { StateListCall { hub: self.hub, _include_data: Default::default(), @@ -545,7 +541,7 @@ impl<'a, C, NC, A> StateMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `stateKey` - The key for the data to be retrieved. - pub fn update(&self, request: &UpdateRequest, state_key: i32) -> StateUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &UpdateRequest, state_key: i32) -> StateUpdateCall<'a, C, A> { StateUpdateCall { hub: self.hub, _request: request.clone(), @@ -596,19 +592,19 @@ impl<'a, C, NC, A> StateMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct StateDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct StateDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AppState, + hub: &'a AppState, _state_key: i32, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for StateDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for StateDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> StateDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> StateDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -729,7 +725,7 @@ impl<'a, C, NC, A> StateDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The key for the data to be retrieved. - pub fn state_key(mut self, new_value: i32) -> StateDeleteCall<'a, C, NC, A> { + pub fn state_key(mut self, new_value: i32) -> StateDeleteCall<'a, C, A> { self._state_key = new_value; self } @@ -740,7 +736,7 @@ impl<'a, C, NC, A> StateDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> StateDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> StateDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -761,7 +757,7 @@ impl<'a, C, NC, A> StateDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> StateDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> StateDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -778,7 +774,7 @@ impl<'a, C, NC, A> StateDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> StateDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> StateDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -816,19 +812,19 @@ impl<'a, C, NC, A> StateDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct StateGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct StateGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AppState, + hub: &'a AppState, _state_key: i32, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for StateGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for StateGetCall<'a, C, A> {} -impl<'a, C, NC, A> StateGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> StateGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -960,7 +956,7 @@ impl<'a, C, NC, A> StateGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The key for the data to be retrieved. - pub fn state_key(mut self, new_value: i32) -> StateGetCall<'a, C, NC, A> { + pub fn state_key(mut self, new_value: i32) -> StateGetCall<'a, C, A> { self._state_key = new_value; self } @@ -971,7 +967,7 @@ impl<'a, C, NC, A> StateGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> StateGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> StateGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -992,7 +988,7 @@ impl<'a, C, NC, A> StateGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> StateGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> StateGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1009,7 +1005,7 @@ impl<'a, C, NC, A> StateGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> StateGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> StateGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1048,10 +1044,10 @@ impl<'a, C, NC, A> StateGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct StateClearCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct StateClearCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AppState, + hub: &'a AppState, _state_key: i32, _current_data_version: Option, _delegate: Option<&'a mut Delegate>, @@ -1059,9 +1055,9 @@ pub struct StateClearCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for StateClearCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for StateClearCall<'a, C, A> {} -impl<'a, C, NC, A> StateClearCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> StateClearCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1196,7 +1192,7 @@ impl<'a, C, NC, A> StateClearCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The key for the data to be retrieved. - pub fn state_key(mut self, new_value: i32) -> StateClearCall<'a, C, NC, A> { + pub fn state_key(mut self, new_value: i32) -> StateClearCall<'a, C, A> { self._state_key = new_value; self } @@ -1204,7 +1200,7 @@ impl<'a, C, NC, A> StateClearCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The version of the data to be cleared. Version strings are returned by the server. - pub fn current_data_version(mut self, new_value: &str) -> StateClearCall<'a, C, NC, A> { + pub fn current_data_version(mut self, new_value: &str) -> StateClearCall<'a, C, A> { self._current_data_version = Some(new_value.to_string()); self } @@ -1215,7 +1211,7 @@ impl<'a, C, NC, A> StateClearCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> StateClearCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> StateClearCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1236,7 +1232,7 @@ impl<'a, C, NC, A> StateClearCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> StateClearCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> StateClearCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1253,7 +1249,7 @@ impl<'a, C, NC, A> StateClearCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> StateClearCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> StateClearCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1292,19 +1288,19 @@ impl<'a, C, NC, A> StateClearCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct StateListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct StateListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AppState, + hub: &'a AppState, _include_data: Option, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for StateListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for StateListCall<'a, C, A> {} -impl<'a, C, NC, A> StateListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> StateListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1412,7 +1408,7 @@ impl<'a, C, NC, A> StateListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether to include the full data in addition to the version number - pub fn include_data(mut self, new_value: bool) -> StateListCall<'a, C, NC, A> { + pub fn include_data(mut self, new_value: bool) -> StateListCall<'a, C, A> { self._include_data = Some(new_value); self } @@ -1423,7 +1419,7 @@ impl<'a, C, NC, A> StateListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> StateListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> StateListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1444,7 +1440,7 @@ impl<'a, C, NC, A> StateListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> StateListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> StateListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1461,7 +1457,7 @@ impl<'a, C, NC, A> StateListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> StateListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> StateListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1506,10 +1502,10 @@ impl<'a, C, NC, A> StateListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct StateUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct StateUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AppState, + hub: &'a AppState, _request: UpdateRequest, _state_key: i32, _current_state_version: Option, @@ -1518,9 +1514,9 @@ pub struct StateUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for StateUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for StateUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> StateUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> StateUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1662,7 +1658,7 @@ impl<'a, C, NC, A> StateUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &UpdateRequest) -> StateUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &UpdateRequest) -> StateUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1672,7 +1668,7 @@ impl<'a, C, NC, A> StateUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The key for the data to be retrieved. - pub fn state_key(mut self, new_value: i32) -> StateUpdateCall<'a, C, NC, A> { + pub fn state_key(mut self, new_value: i32) -> StateUpdateCall<'a, C, A> { self._state_key = new_value; self } @@ -1680,7 +1676,7 @@ impl<'a, C, NC, A> StateUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The version of the app state your application is attempting to update. If this does not match the current version, this method will return a conflict error. If there is no data stored on the server for this key, the update will succeed irrespective of the value of this parameter. - pub fn current_state_version(mut self, new_value: &str) -> StateUpdateCall<'a, C, NC, A> { + pub fn current_state_version(mut self, new_value: &str) -> StateUpdateCall<'a, C, A> { self._current_state_version = Some(new_value.to_string()); self } @@ -1691,7 +1687,7 @@ impl<'a, C, NC, A> StateUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> StateUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> StateUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1712,7 +1708,7 @@ impl<'a, C, NC, A> StateUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> StateUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> StateUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1729,7 +1725,7 @@ impl<'a, C, NC, A> StateUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> StateUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> StateUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/audit1/Cargo.toml b/gen/audit1/Cargo.toml index 8d1d7ad2e50..1c296b5ec90 100644 --- a/gen/audit1/Cargo.toml +++ b/gen/audit1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-audit1" -version = "0.1.4+20130108" +version = "0.1.5+20130108" authors = ["Sebastian Thiel "] description = "A complete library to interact with audit (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/audit1" homepage = "https://developers.google.com/google-apps/admin-audit/get_started" -documentation = "http://byron.github.io/google-apis-rs/google-audit1" +documentation = "http://byron.github.io/google-apis-rs/google_audit1" license = "MIT" keywords = ["audit", "google", "protocol", "web", "api"] diff --git a/gen/audit1/README.md b/gen/audit1/README.md index cbbefe9ccc1..6ad364eea11 100644 --- a/gen/audit1/README.md +++ b/gen/audit1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-audit1` library allows access to all features of the *Google audit* service. -This documentation was generated from *audit* crate version *0.1.4+20130108*, where *20130108* is the exact revision of the *audit:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *audit* crate version *0.1.5+20130108*, where *20130108* is the exact revision of the *audit:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *audit* *v1* API can be found at the [official documentation site](https://developers.google.com/google-apps/admin-audit/get_started). diff --git a/gen/audit1/src/cmn.rs b/gen/audit1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/audit1/src/cmn.rs +++ b/gen/audit1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/audit1/src/lib.rs b/gen/audit1/src/lib.rs index eccb29e57ed..6ef6f2a5301 100644 --- a/gen/audit1/src/lib.rs +++ b/gen/audit1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *audit* crate version *0.1.4+20130108*, where *20130108* is the exact revision of the *audit:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *audit* crate version *0.1.5+20130108*, where *20130108* is the exact revision of the *audit:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *audit* *v1* API can be found at the //! [official documentation site](https://developers.google.com/google-apps/admin-audit/get_started). @@ -197,7 +197,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -275,34 +274,31 @@ pub use cmn::{MultiPartReader, ToParts, MethodInfo, Result, Error, CallBuilder, /// } /// # } /// ``` -pub struct Audit { +pub struct Audit { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Audit {} +impl<'a, C, A> Hub for Audit {} -impl<'a, C, NC, A> Audit - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Audit + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Audit { + pub fn new(client: C, authenticator: A) -> Audit { Audit { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn activities(&'a self) -> ActivityMethods<'a, C, NC, A> { + pub fn activities(&'a self) -> ActivityMethods<'a, C, A> { ActivityMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -476,15 +472,15 @@ impl Part for ActivityEvents {} /// let rb = hub.activities(); /// # } /// ``` -pub struct ActivityMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ActivityMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Audit, + hub: &'a Audit, } -impl<'a, C, NC, A> MethodsBuilder for ActivityMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ActivityMethods<'a, C, A> {} -impl<'a, C, NC, A> ActivityMethods<'a, C, NC, A> { +impl<'a, C, A> ActivityMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -494,7 +490,7 @@ impl<'a, C, NC, A> ActivityMethods<'a, C, NC, A> { /// /// * `customerId` - Represents the customer who is the owner of target object on which action was performed. /// * `applicationId` - Application ID of the application on which the event was performed. - pub fn list(&self, customer_id: &str, application_id: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn list(&self, customer_id: &str, application_id: &str) -> ActivityListCall<'a, C, A> { ActivityListCall { hub: self.hub, _customer_id: customer_id.to_string(), @@ -561,10 +557,10 @@ impl<'a, C, NC, A> ActivityMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct ActivityListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ActivityListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Audit, + hub: &'a Audit, _customer_id: String, _application_id: String, _start_time: Option, @@ -580,9 +576,9 @@ pub struct ActivityListCall<'a, C, NC, A> _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for ActivityListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ActivityListCall<'a, C, A> {} -impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ActivityListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -740,7 +736,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Represents the customer who is the owner of target object on which action was performed. - pub fn customer_id(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -750,7 +746,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Application ID of the application on which the event was performed. - pub fn application_id(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn application_id(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._application_id = new_value.to_string(); self } @@ -758,7 +754,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Return events which occured at or after this time. - pub fn start_time(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn start_time(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._start_time = Some(new_value.to_string()); self } @@ -766,7 +762,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Number of activity records to be shown in each page. - pub fn max_results(mut self, new_value: i32) -> ActivityListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ActivityListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -774,7 +770,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Name of the event being queried. - pub fn event_name(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn event_name(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._event_name = Some(new_value.to_string()); self } @@ -782,7 +778,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Return events which occured at or before this time. - pub fn end_time(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn end_time(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._end_time = Some(new_value.to_string()); self } @@ -790,7 +786,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Next page URL. - pub fn continuation_token(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn continuation_token(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._continuation_token = Some(new_value.to_string()); self } @@ -798,7 +794,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Type of the caller. - pub fn caller(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn caller(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._caller = Some(new_value.to_string()); self } @@ -806,7 +802,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// IP Address of host where the event was performed. Supports both IPv4 and IPv6 addresses. - pub fn actor_ip_address(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn actor_ip_address(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._actor_ip_address = Some(new_value.to_string()); self } @@ -814,7 +810,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Email address of the user who performed the action. - pub fn actor_email(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn actor_email(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._actor_email = Some(new_value.to_string()); self } @@ -822,7 +818,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Application ID of the application which interacted on behalf of the user while performing the event. - pub fn actor_application_id(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn actor_application_id(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._actor_application_id = Some(new_value.to_string()); self } @@ -833,7 +829,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivityListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivityListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -854,7 +850,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ActivityListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ActivityListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self diff --git a/gen/autoscaler1_beta2/Cargo.toml b/gen/autoscaler1_beta2/Cargo.toml index 7fe68df4187..67c0acde7f9 100644 --- a/gen/autoscaler1_beta2/Cargo.toml +++ b/gen/autoscaler1_beta2/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-autoscaler1_beta2" -version = "0.1.4+20141112" +version = "0.1.5+20141112" authors = ["Sebastian Thiel "] description = "A complete library to interact with autoscaler (protocol v1beta2)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/autoscaler1_beta2" homepage = "http://developers.google.com/compute/docs/autoscaler" -documentation = "http://byron.github.io/google-apis-rs/google-autoscaler1_beta2" +documentation = "http://byron.github.io/google-apis-rs/google_autoscaler1_beta2" license = "MIT" keywords = ["autoscaler", "google", "protocol", "web", "api"] diff --git a/gen/autoscaler1_beta2/README.md b/gen/autoscaler1_beta2/README.md index 2e6d1c2a715..eb7d0fb711c 100644 --- a/gen/autoscaler1_beta2/README.md +++ b/gen/autoscaler1_beta2/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-autoscaler1_beta2` library allows access to all features of the *Google autoscaler* service. -This documentation was generated from *autoscaler* crate version *0.1.4+20141112*, where *20141112* is the exact revision of the *autoscaler:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *autoscaler* crate version *0.1.5+20141112*, where *20141112* is the exact revision of the *autoscaler:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *autoscaler* *v1_beta2* API can be found at the [official documentation site](http://developers.google.com/compute/docs/autoscaler). diff --git a/gen/autoscaler1_beta2/src/cmn.rs b/gen/autoscaler1_beta2/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/autoscaler1_beta2/src/cmn.rs +++ b/gen/autoscaler1_beta2/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/autoscaler1_beta2/src/lib.rs b/gen/autoscaler1_beta2/src/lib.rs index 95eaf45cb7b..e84038abdd3 100644 --- a/gen/autoscaler1_beta2/src/lib.rs +++ b/gen/autoscaler1_beta2/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *autoscaler* crate version *0.1.4+20141112*, where *20141112* is the exact revision of the *autoscaler:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *autoscaler* crate version *0.1.5+20141112*, where *20141112* is the exact revision of the *autoscaler:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *autoscaler* *v1_beta2* API can be found at the //! [official documentation site](http://developers.google.com/compute/docs/autoscaler). @@ -200,7 +200,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -298,40 +297,37 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct AutoscalerHub { +pub struct AutoscalerHub { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for AutoscalerHub {} +impl<'a, C, A> Hub for AutoscalerHub {} -impl<'a, C, NC, A> AutoscalerHub - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AutoscalerHub + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> AutoscalerHub { + pub fn new(client: C, authenticator: A) -> AutoscalerHub { AutoscalerHub { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn autoscalers(&'a self) -> AutoscalerMethods<'a, C, NC, A> { + pub fn autoscalers(&'a self) -> AutoscalerMethods<'a, C, A> { AutoscalerMethods { hub: &self } } - pub fn zone_operations(&'a self) -> ZoneOperationMethods<'a, C, NC, A> { + pub fn zone_operations(&'a self) -> ZoneOperationMethods<'a, C, A> { ZoneOperationMethods { hub: &self } } - pub fn zones(&'a self) -> ZoneMethods<'a, C, NC, A> { + pub fn zones(&'a self) -> ZoneMethods<'a, C, A> { ZoneMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -799,15 +795,15 @@ impl ResponseResult for Autoscaler {} /// let rb = hub.zones(); /// # } /// ``` -pub struct ZoneMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AutoscalerHub, + hub: &'a AutoscalerHub, } -impl<'a, C, NC, A> MethodsBuilder for ZoneMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ZoneMethods<'a, C, A> {} -impl<'a, C, NC, A> ZoneMethods<'a, C, NC, A> { +impl<'a, C, A> ZoneMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -816,7 +812,7 @@ impl<'a, C, NC, A> ZoneMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - No description provided. - pub fn list(&self, project: &str) -> ZoneListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> ZoneListCall<'a, C, A> { ZoneListCall { hub: self.hub, _project: project.to_string(), @@ -860,15 +856,15 @@ impl<'a, C, NC, A> ZoneMethods<'a, C, NC, A> { /// let rb = hub.zone_operations(); /// # } /// ``` -pub struct ZoneOperationMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneOperationMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AutoscalerHub, + hub: &'a AutoscalerHub, } -impl<'a, C, NC, A> MethodsBuilder for ZoneOperationMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ZoneOperationMethods<'a, C, A> {} -impl<'a, C, NC, A> ZoneOperationMethods<'a, C, NC, A> { +impl<'a, C, A> ZoneOperationMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -878,7 +874,7 @@ impl<'a, C, NC, A> ZoneOperationMethods<'a, C, NC, A> { /// /// * `project` - No description provided. /// * `zone` - No description provided. - pub fn list(&self, project: &str, zone: &str) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, zone: &str) -> ZoneOperationListCall<'a, C, A> { ZoneOperationListCall { hub: self.hub, _project: project.to_string(), @@ -901,7 +897,7 @@ impl<'a, C, NC, A> ZoneOperationMethods<'a, C, NC, A> { /// * `project` - No description provided. /// * `zone` - No description provided. /// * `operation` - No description provided. - pub fn delete(&self, project: &str, zone: &str, operation: &str) -> ZoneOperationDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, zone: &str, operation: &str) -> ZoneOperationDeleteCall<'a, C, A> { ZoneOperationDeleteCall { hub: self.hub, _project: project.to_string(), @@ -922,7 +918,7 @@ impl<'a, C, NC, A> ZoneOperationMethods<'a, C, NC, A> { /// * `project` - No description provided. /// * `zone` - No description provided. /// * `operation` - No description provided. - pub fn get(&self, project: &str, zone: &str, operation: &str) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, zone: &str, operation: &str) -> ZoneOperationGetCall<'a, C, A> { ZoneOperationGetCall { hub: self.hub, _project: project.to_string(), @@ -965,15 +961,15 @@ impl<'a, C, NC, A> ZoneOperationMethods<'a, C, NC, A> { /// let rb = hub.autoscalers(); /// # } /// ``` -pub struct AutoscalerMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AutoscalerMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AutoscalerHub, + hub: &'a AutoscalerHub, } -impl<'a, C, NC, A> MethodsBuilder for AutoscalerMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AutoscalerMethods<'a, C, A> {} -impl<'a, C, NC, A> AutoscalerMethods<'a, C, NC, A> { +impl<'a, C, A> AutoscalerMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -983,7 +979,7 @@ impl<'a, C, NC, A> AutoscalerMethods<'a, C, NC, A> { /// /// * `project` - Project ID of Autoscaler resource. /// * `zone` - Zone name of Autoscaler resource. - pub fn list(&self, project: &str, zone: &str) -> AutoscalerListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, zone: &str) -> AutoscalerListCall<'a, C, A> { AutoscalerListCall { hub: self.hub, _project: project.to_string(), @@ -1007,7 +1003,7 @@ impl<'a, C, NC, A> AutoscalerMethods<'a, C, NC, A> { /// * `project` - Project ID of Autoscaler resource. /// * `zone` - Zone name of Autoscaler resource. /// * `autoscaler` - Name of the Autoscaler resource. - pub fn update(&self, request: &Autoscaler, project: &str, zone: &str, autoscaler: &str) -> AutoscalerUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Autoscaler, project: &str, zone: &str, autoscaler: &str) -> AutoscalerUpdateCall<'a, C, A> { AutoscalerUpdateCall { hub: self.hub, _request: request.clone(), @@ -1030,7 +1026,7 @@ impl<'a, C, NC, A> AutoscalerMethods<'a, C, NC, A> { /// * `project` - Project ID of Autoscaler resource. /// * `zone` - Zone name of Autoscaler resource. /// * `autoscaler` - Name of the Autoscaler resource. - pub fn patch(&self, request: &Autoscaler, project: &str, zone: &str, autoscaler: &str) -> AutoscalerPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Autoscaler, project: &str, zone: &str, autoscaler: &str) -> AutoscalerPatchCall<'a, C, A> { AutoscalerPatchCall { hub: self.hub, _request: request.clone(), @@ -1052,7 +1048,7 @@ impl<'a, C, NC, A> AutoscalerMethods<'a, C, NC, A> { /// * `project` - Project ID of Autoscaler resource. /// * `zone` - Zone name of Autoscaler resource. /// * `autoscaler` - Name of the Autoscaler resource. - pub fn delete(&self, project: &str, zone: &str, autoscaler: &str) -> AutoscalerDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, zone: &str, autoscaler: &str) -> AutoscalerDeleteCall<'a, C, A> { AutoscalerDeleteCall { hub: self.hub, _project: project.to_string(), @@ -1073,7 +1069,7 @@ impl<'a, C, NC, A> AutoscalerMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Project ID of Autoscaler resource. /// * `zone` - Zone name of Autoscaler resource. - pub fn insert(&self, request: &Autoscaler, project: &str, zone: &str) -> AutoscalerInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Autoscaler, project: &str, zone: &str) -> AutoscalerInsertCall<'a, C, A> { AutoscalerInsertCall { hub: self.hub, _request: request.clone(), @@ -1094,7 +1090,7 @@ impl<'a, C, NC, A> AutoscalerMethods<'a, C, NC, A> { /// * `project` - Project ID of Autoscaler resource. /// * `zone` - Zone name of Autoscaler resource. /// * `autoscaler` - Name of the Autoscaler resource. - pub fn get(&self, project: &str, zone: &str, autoscaler: &str) -> AutoscalerGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, zone: &str, autoscaler: &str) -> AutoscalerGetCall<'a, C, A> { AutoscalerGetCall { hub: self.hub, _project: project.to_string(), @@ -1148,10 +1144,10 @@ impl<'a, C, NC, A> AutoscalerMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct ZoneListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AutoscalerHub, + hub: &'a AutoscalerHub, _project: String, _page_token: Option, _max_results: Option, @@ -1161,9 +1157,9 @@ pub struct ZoneListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ZoneListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ZoneListCall<'a, C, A> {} -impl<'a, C, NC, A> ZoneListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ZoneListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1303,28 +1299,28 @@ impl<'a, C, NC, A> ZoneListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn project(mut self, new_value: &str) -> ZoneListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ZoneListCall<'a, C, A> { self._project = new_value.to_string(); self } /// Sets the *page token* query property to the given value. /// /// - pub fn page_token(mut self, new_value: &str) -> ZoneListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ZoneListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } /// Sets the *max results* query property to the given value. /// /// - pub fn max_results(mut self, new_value: u32) -> ZoneListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> ZoneListCall<'a, C, A> { self._max_results = Some(new_value); self } /// Sets the *filter* query property to the given value. /// /// - pub fn filter(mut self, new_value: &str) -> ZoneListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> ZoneListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -1335,7 +1331,7 @@ impl<'a, C, NC, A> ZoneListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1356,7 +1352,7 @@ impl<'a, C, NC, A> ZoneListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ZoneListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ZoneListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1373,7 +1369,7 @@ impl<'a, C, NC, A> ZoneListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ZoneListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ZoneListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1414,10 +1410,10 @@ impl<'a, C, NC, A> ZoneListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct ZoneOperationListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneOperationListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AutoscalerHub, + hub: &'a AutoscalerHub, _project: String, _zone: String, _page_token: Option, @@ -1428,9 +1424,9 @@ pub struct ZoneOperationListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ZoneOperationListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ZoneOperationListCall<'a, C, A> {} -impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ZoneOperationListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1571,7 +1567,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn project(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1580,28 +1576,28 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn zone(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, A> { self._zone = new_value.to_string(); self } /// Sets the *page token* query property to the given value. /// /// - pub fn page_token(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } /// Sets the *max results* query property to the given value. /// /// - pub fn max_results(mut self, new_value: u32) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> ZoneOperationListCall<'a, C, A> { self._max_results = Some(new_value); self } /// Sets the *filter* query property to the given value. /// /// - pub fn filter(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -1612,7 +1608,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneOperationListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1633,7 +1629,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ZoneOperationListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ZoneOperationListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1650,7 +1646,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ZoneOperationListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ZoneOperationListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1688,10 +1684,10 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct ZoneOperationDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneOperationDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AutoscalerHub, + hub: &'a AutoscalerHub, _project: String, _zone: String, _operation: String, @@ -1700,9 +1696,9 @@ pub struct ZoneOperationDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ZoneOperationDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ZoneOperationDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ZoneOperationDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ZoneOperationDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1824,7 +1820,7 @@ impl<'a, C, NC, A> ZoneOperationDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn project(mut self, new_value: &str) -> ZoneOperationDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ZoneOperationDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1833,7 +1829,7 @@ impl<'a, C, NC, A> ZoneOperationDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn zone(mut self, new_value: &str) -> ZoneOperationDeleteCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> ZoneOperationDeleteCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -1842,7 +1838,7 @@ impl<'a, C, NC, A> ZoneOperationDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn operation(mut self, new_value: &str) -> ZoneOperationDeleteCall<'a, C, NC, A> { + pub fn operation(mut self, new_value: &str) -> ZoneOperationDeleteCall<'a, C, A> { self._operation = new_value.to_string(); self } @@ -1853,7 +1849,7 @@ impl<'a, C, NC, A> ZoneOperationDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneOperationDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneOperationDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1874,7 +1870,7 @@ impl<'a, C, NC, A> ZoneOperationDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ZoneOperationDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ZoneOperationDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1891,7 +1887,7 @@ impl<'a, C, NC, A> ZoneOperationDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ZoneOperationDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ZoneOperationDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1929,10 +1925,10 @@ impl<'a, C, NC, A> ZoneOperationDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct ZoneOperationGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneOperationGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AutoscalerHub, + hub: &'a AutoscalerHub, _project: String, _zone: String, _operation: String, @@ -1941,9 +1937,9 @@ pub struct ZoneOperationGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ZoneOperationGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ZoneOperationGetCall<'a, C, A> {} -impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ZoneOperationGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2076,7 +2072,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn project(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2085,7 +2081,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn zone(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -2094,7 +2090,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn operation(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn operation(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, A> { self._operation = new_value.to_string(); self } @@ -2105,7 +2101,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneOperationGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2126,7 +2122,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ZoneOperationGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ZoneOperationGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2143,7 +2139,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ZoneOperationGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ZoneOperationGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2184,10 +2180,10 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct AutoscalerListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AutoscalerListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AutoscalerHub, + hub: &'a AutoscalerHub, _project: String, _zone: String, _page_token: Option, @@ -2198,9 +2194,9 @@ pub struct AutoscalerListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AutoscalerListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AutoscalerListCall<'a, C, A> {} -impl<'a, C, NC, A> AutoscalerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AutoscalerListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2342,7 +2338,7 @@ impl<'a, C, NC, A> AutoscalerListCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Project ID of Autoscaler resource. - pub fn project(mut self, new_value: &str) -> AutoscalerListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> AutoscalerListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2352,28 +2348,28 @@ impl<'a, C, NC, A> AutoscalerListCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Zone name of Autoscaler resource. - pub fn zone(mut self, new_value: &str) -> AutoscalerListCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> AutoscalerListCall<'a, C, A> { self._zone = new_value.to_string(); self } /// Sets the *page token* query property to the given value. /// /// - pub fn page_token(mut self, new_value: &str) -> AutoscalerListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AutoscalerListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } /// Sets the *max results* query property to the given value. /// /// - pub fn max_results(mut self, new_value: u32) -> AutoscalerListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> AutoscalerListCall<'a, C, A> { self._max_results = Some(new_value); self } /// Sets the *filter* query property to the given value. /// /// - pub fn filter(mut self, new_value: &str) -> AutoscalerListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> AutoscalerListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -2384,7 +2380,7 @@ impl<'a, C, NC, A> AutoscalerListCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AutoscalerListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AutoscalerListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2405,7 +2401,7 @@ impl<'a, C, NC, A> AutoscalerListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AutoscalerListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AutoscalerListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2422,7 +2418,7 @@ impl<'a, C, NC, A> AutoscalerListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AutoscalerListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AutoscalerListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2466,10 +2462,10 @@ impl<'a, C, NC, A> AutoscalerListCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct AutoscalerUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AutoscalerUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AutoscalerHub, + hub: &'a AutoscalerHub, _request: Autoscaler, _project: String, _zone: String, @@ -2479,9 +2475,9 @@ pub struct AutoscalerUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AutoscalerUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AutoscalerUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AutoscalerUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AutoscalerUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2622,7 +2618,7 @@ impl<'a, C, NC, A> AutoscalerUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Autoscaler) -> AutoscalerUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Autoscaler) -> AutoscalerUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2632,7 +2628,7 @@ impl<'a, C, NC, A> AutoscalerUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Project ID of Autoscaler resource. - pub fn project(mut self, new_value: &str) -> AutoscalerUpdateCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> AutoscalerUpdateCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2642,7 +2638,7 @@ impl<'a, C, NC, A> AutoscalerUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Zone name of Autoscaler resource. - pub fn zone(mut self, new_value: &str) -> AutoscalerUpdateCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> AutoscalerUpdateCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -2652,7 +2648,7 @@ impl<'a, C, NC, A> AutoscalerUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Name of the Autoscaler resource. - pub fn autoscaler(mut self, new_value: &str) -> AutoscalerUpdateCall<'a, C, NC, A> { + pub fn autoscaler(mut self, new_value: &str) -> AutoscalerUpdateCall<'a, C, A> { self._autoscaler = new_value.to_string(); self } @@ -2663,7 +2659,7 @@ impl<'a, C, NC, A> AutoscalerUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AutoscalerUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AutoscalerUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2684,7 +2680,7 @@ impl<'a, C, NC, A> AutoscalerUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AutoscalerUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AutoscalerUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2701,7 +2697,7 @@ impl<'a, C, NC, A> AutoscalerUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AutoscalerUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AutoscalerUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2745,10 +2741,10 @@ impl<'a, C, NC, A> AutoscalerUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct AutoscalerPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AutoscalerPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AutoscalerHub, + hub: &'a AutoscalerHub, _request: Autoscaler, _project: String, _zone: String, @@ -2758,9 +2754,9 @@ pub struct AutoscalerPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AutoscalerPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AutoscalerPatchCall<'a, C, A> {} -impl<'a, C, NC, A> AutoscalerPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AutoscalerPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2901,7 +2897,7 @@ impl<'a, C, NC, A> AutoscalerPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Autoscaler) -> AutoscalerPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Autoscaler) -> AutoscalerPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2911,7 +2907,7 @@ impl<'a, C, NC, A> AutoscalerPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Project ID of Autoscaler resource. - pub fn project(mut self, new_value: &str) -> AutoscalerPatchCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> AutoscalerPatchCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2921,7 +2917,7 @@ impl<'a, C, NC, A> AutoscalerPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Zone name of Autoscaler resource. - pub fn zone(mut self, new_value: &str) -> AutoscalerPatchCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> AutoscalerPatchCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -2931,7 +2927,7 @@ impl<'a, C, NC, A> AutoscalerPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Name of the Autoscaler resource. - pub fn autoscaler(mut self, new_value: &str) -> AutoscalerPatchCall<'a, C, NC, A> { + pub fn autoscaler(mut self, new_value: &str) -> AutoscalerPatchCall<'a, C, A> { self._autoscaler = new_value.to_string(); self } @@ -2942,7 +2938,7 @@ impl<'a, C, NC, A> AutoscalerPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AutoscalerPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AutoscalerPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2963,7 +2959,7 @@ impl<'a, C, NC, A> AutoscalerPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AutoscalerPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AutoscalerPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2980,7 +2976,7 @@ impl<'a, C, NC, A> AutoscalerPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AutoscalerPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AutoscalerPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3018,10 +3014,10 @@ impl<'a, C, NC, A> AutoscalerPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct AutoscalerDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AutoscalerDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AutoscalerHub, + hub: &'a AutoscalerHub, _project: String, _zone: String, _autoscaler: String, @@ -3030,9 +3026,9 @@ pub struct AutoscalerDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AutoscalerDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AutoscalerDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> AutoscalerDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AutoscalerDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3166,7 +3162,7 @@ impl<'a, C, NC, A> AutoscalerDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Project ID of Autoscaler resource. - pub fn project(mut self, new_value: &str) -> AutoscalerDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> AutoscalerDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -3176,7 +3172,7 @@ impl<'a, C, NC, A> AutoscalerDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Zone name of Autoscaler resource. - pub fn zone(mut self, new_value: &str) -> AutoscalerDeleteCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> AutoscalerDeleteCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -3186,7 +3182,7 @@ impl<'a, C, NC, A> AutoscalerDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Name of the Autoscaler resource. - pub fn autoscaler(mut self, new_value: &str) -> AutoscalerDeleteCall<'a, C, NC, A> { + pub fn autoscaler(mut self, new_value: &str) -> AutoscalerDeleteCall<'a, C, A> { self._autoscaler = new_value.to_string(); self } @@ -3197,7 +3193,7 @@ impl<'a, C, NC, A> AutoscalerDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AutoscalerDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AutoscalerDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3218,7 +3214,7 @@ impl<'a, C, NC, A> AutoscalerDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AutoscalerDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AutoscalerDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3235,7 +3231,7 @@ impl<'a, C, NC, A> AutoscalerDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AutoscalerDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AutoscalerDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3279,10 +3275,10 @@ impl<'a, C, NC, A> AutoscalerDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct AutoscalerInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AutoscalerInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AutoscalerHub, + hub: &'a AutoscalerHub, _request: Autoscaler, _project: String, _zone: String, @@ -3291,9 +3287,9 @@ pub struct AutoscalerInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AutoscalerInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AutoscalerInsertCall<'a, C, A> {} -impl<'a, C, NC, A> AutoscalerInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AutoscalerInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3433,7 +3429,7 @@ impl<'a, C, NC, A> AutoscalerInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Autoscaler) -> AutoscalerInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Autoscaler) -> AutoscalerInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3443,7 +3439,7 @@ impl<'a, C, NC, A> AutoscalerInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Project ID of Autoscaler resource. - pub fn project(mut self, new_value: &str) -> AutoscalerInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> AutoscalerInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -3453,7 +3449,7 @@ impl<'a, C, NC, A> AutoscalerInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Zone name of Autoscaler resource. - pub fn zone(mut self, new_value: &str) -> AutoscalerInsertCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> AutoscalerInsertCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -3464,7 +3460,7 @@ impl<'a, C, NC, A> AutoscalerInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AutoscalerInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AutoscalerInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3485,7 +3481,7 @@ impl<'a, C, NC, A> AutoscalerInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AutoscalerInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AutoscalerInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3502,7 +3498,7 @@ impl<'a, C, NC, A> AutoscalerInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AutoscalerInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AutoscalerInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3540,10 +3536,10 @@ impl<'a, C, NC, A> AutoscalerInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct AutoscalerGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AutoscalerGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a AutoscalerHub, + hub: &'a AutoscalerHub, _project: String, _zone: String, _autoscaler: String, @@ -3552,9 +3548,9 @@ pub struct AutoscalerGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AutoscalerGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AutoscalerGetCall<'a, C, A> {} -impl<'a, C, NC, A> AutoscalerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AutoscalerGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3688,7 +3684,7 @@ impl<'a, C, NC, A> AutoscalerGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Project ID of Autoscaler resource. - pub fn project(mut self, new_value: &str) -> AutoscalerGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> AutoscalerGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -3698,7 +3694,7 @@ impl<'a, C, NC, A> AutoscalerGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Zone name of Autoscaler resource. - pub fn zone(mut self, new_value: &str) -> AutoscalerGetCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> AutoscalerGetCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -3708,7 +3704,7 @@ impl<'a, C, NC, A> AutoscalerGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Name of the Autoscaler resource. - pub fn autoscaler(mut self, new_value: &str) -> AutoscalerGetCall<'a, C, NC, A> { + pub fn autoscaler(mut self, new_value: &str) -> AutoscalerGetCall<'a, C, A> { self._autoscaler = new_value.to_string(); self } @@ -3719,7 +3715,7 @@ impl<'a, C, NC, A> AutoscalerGetCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AutoscalerGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AutoscalerGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3740,7 +3736,7 @@ impl<'a, C, NC, A> AutoscalerGetCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AutoscalerGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AutoscalerGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3757,7 +3753,7 @@ impl<'a, C, NC, A> AutoscalerGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AutoscalerGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AutoscalerGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/bigquery2/Cargo.toml b/gen/bigquery2/Cargo.toml index a9f83cb0f6f..b94dbb128ac 100644 --- a/gen/bigquery2/Cargo.toml +++ b/gen/bigquery2/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-bigquery2" -version = "0.1.4+20150326" +version = "0.1.5+20150326" authors = ["Sebastian Thiel "] description = "A complete library to interact with bigquery (protocol v2)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/bigquery2" homepage = "https://developers.google.com/bigquery/docs/overview" -documentation = "http://byron.github.io/google-apis-rs/google-bigquery2" +documentation = "http://byron.github.io/google-apis-rs/google_bigquery2" license = "MIT" keywords = ["bigquery", "google", "protocol", "web", "api"] diff --git a/gen/bigquery2/README.md b/gen/bigquery2/README.md index 2bac273db3d..2d8d493c19d 100644 --- a/gen/bigquery2/README.md +++ b/gen/bigquery2/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-bigquery2` library allows access to all features of the *Google bigquery* service. -This documentation was generated from *bigquery* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *bigquery:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *bigquery* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *bigquery:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *bigquery* *v2* API can be found at the [official documentation site](https://developers.google.com/bigquery/docs/overview). diff --git a/gen/bigquery2/src/cmn.rs b/gen/bigquery2/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/bigquery2/src/cmn.rs +++ b/gen/bigquery2/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/bigquery2/src/lib.rs b/gen/bigquery2/src/lib.rs index 73d50fb3836..181d97f8844 100644 --- a/gen/bigquery2/src/lib.rs +++ b/gen/bigquery2/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *bigquery* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *bigquery:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *bigquery* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *bigquery:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *bigquery* *v2* API can be found at the //! [official documentation site](https://developers.google.com/bigquery/docs/overview). @@ -211,7 +211,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -328,46 +327,43 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Bigquery { +pub struct Bigquery { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Bigquery {} +impl<'a, C, A> Hub for Bigquery {} -impl<'a, C, NC, A> Bigquery - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Bigquery + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Bigquery { + pub fn new(client: C, authenticator: A) -> Bigquery { Bigquery { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn datasets(&'a self) -> DatasetMethods<'a, C, NC, A> { + pub fn datasets(&'a self) -> DatasetMethods<'a, C, A> { DatasetMethods { hub: &self } } - pub fn jobs(&'a self) -> JobMethods<'a, C, NC, A> { + pub fn jobs(&'a self) -> JobMethods<'a, C, A> { JobMethods { hub: &self } } - pub fn projects(&'a self) -> ProjectMethods<'a, C, NC, A> { + pub fn projects(&'a self) -> ProjectMethods<'a, C, A> { ProjectMethods { hub: &self } } - pub fn tabledata(&'a self) -> TabledataMethods<'a, C, NC, A> { + pub fn tabledata(&'a self) -> TabledataMethods<'a, C, A> { TabledataMethods { hub: &self } } - pub fn tables(&'a self) -> TableMethods<'a, C, NC, A> { + pub fn tables(&'a self) -> TableMethods<'a, C, A> { TableMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -1590,15 +1586,15 @@ impl Part for JobConfigurationTableCopy {} /// let rb = hub.tables(); /// # } /// ``` -pub struct TableMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, } -impl<'a, C, NC, A> MethodsBuilder for TableMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TableMethods<'a, C, A> {} -impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { +impl<'a, C, A> TableMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1610,7 +1606,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// * `projectId` - Project ID of the table to update /// * `datasetId` - Dataset ID of the table to update /// * `tableId` - Table ID of the table to update - pub fn update(&self, request: &Table, project_id: &str, dataset_id: &str, table_id: &str) -> TableUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Table, project_id: &str, dataset_id: &str, table_id: &str) -> TableUpdateCall<'a, C, A> { TableUpdateCall { hub: self.hub, _request: request.clone(), @@ -1632,7 +1628,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `projectId` - Project ID of the new table /// * `datasetId` - Dataset ID of the new table - pub fn insert(&self, request: &Table, project_id: &str, dataset_id: &str) -> TableInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Table, project_id: &str, dataset_id: &str) -> TableInsertCall<'a, C, A> { TableInsertCall { hub: self.hub, _request: request.clone(), @@ -1652,7 +1648,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// /// * `projectId` - Project ID of the tables to list /// * `datasetId` - Dataset ID of the tables to list - pub fn list(&self, project_id: &str, dataset_id: &str) -> TableListCall<'a, C, NC, A> { + pub fn list(&self, project_id: &str, dataset_id: &str) -> TableListCall<'a, C, A> { TableListCall { hub: self.hub, _project_id: project_id.to_string(), @@ -1674,7 +1670,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// * `projectId` - Project ID of the table to delete /// * `datasetId` - Dataset ID of the table to delete /// * `tableId` - Table ID of the table to delete - pub fn delete(&self, project_id: &str, dataset_id: &str, table_id: &str) -> TableDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project_id: &str, dataset_id: &str, table_id: &str) -> TableDeleteCall<'a, C, A> { TableDeleteCall { hub: self.hub, _project_id: project_id.to_string(), @@ -1695,7 +1691,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// * `projectId` - Project ID of the requested table /// * `datasetId` - Dataset ID of the requested table /// * `tableId` - Table ID of the requested table - pub fn get(&self, project_id: &str, dataset_id: &str, table_id: &str) -> TableGetCall<'a, C, NC, A> { + pub fn get(&self, project_id: &str, dataset_id: &str, table_id: &str) -> TableGetCall<'a, C, A> { TableGetCall { hub: self.hub, _project_id: project_id.to_string(), @@ -1717,7 +1713,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// * `projectId` - Project ID of the table to update /// * `datasetId` - Dataset ID of the table to update /// * `tableId` - Table ID of the table to update - pub fn patch(&self, request: &Table, project_id: &str, dataset_id: &str, table_id: &str) -> TablePatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Table, project_id: &str, dataset_id: &str, table_id: &str) -> TablePatchCall<'a, C, A> { TablePatchCall { hub: self.hub, _request: request.clone(), @@ -1761,15 +1757,15 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// let rb = hub.datasets(); /// # } /// ``` -pub struct DatasetMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatasetMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, } -impl<'a, C, NC, A> MethodsBuilder for DatasetMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for DatasetMethods<'a, C, A> {} -impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { +impl<'a, C, A> DatasetMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1780,7 +1776,7 @@ impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `projectId` - Project ID of the dataset being updated /// * `datasetId` - Dataset ID of the dataset being updated - pub fn patch(&self, request: &Dataset, project_id: &str, dataset_id: &str) -> DatasetPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Dataset, project_id: &str, dataset_id: &str) -> DatasetPatchCall<'a, C, A> { DatasetPatchCall { hub: self.hub, _request: request.clone(), @@ -1800,7 +1796,7 @@ impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { /// /// * `projectId` - Project ID of the requested dataset /// * `datasetId` - Dataset ID of the requested dataset - pub fn get(&self, project_id: &str, dataset_id: &str) -> DatasetGetCall<'a, C, NC, A> { + pub fn get(&self, project_id: &str, dataset_id: &str) -> DatasetGetCall<'a, C, A> { DatasetGetCall { hub: self.hub, _project_id: project_id.to_string(), @@ -1818,7 +1814,7 @@ impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { /// # Arguments /// /// * `projectId` - Project ID of the datasets to be listed - pub fn list(&self, project_id: &str) -> DatasetListCall<'a, C, NC, A> { + pub fn list(&self, project_id: &str) -> DatasetListCall<'a, C, A> { DatasetListCall { hub: self.hub, _project_id: project_id.to_string(), @@ -1840,7 +1836,7 @@ impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `projectId` - Project ID of the dataset being updated /// * `datasetId` - Dataset ID of the dataset being updated - pub fn update(&self, request: &Dataset, project_id: &str, dataset_id: &str) -> DatasetUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Dataset, project_id: &str, dataset_id: &str) -> DatasetUpdateCall<'a, C, A> { DatasetUpdateCall { hub: self.hub, _request: request.clone(), @@ -1860,7 +1856,7 @@ impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { /// /// * `projectId` - Project ID of the dataset being deleted /// * `datasetId` - Dataset ID of dataset being deleted - pub fn delete(&self, project_id: &str, dataset_id: &str) -> DatasetDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project_id: &str, dataset_id: &str) -> DatasetDeleteCall<'a, C, A> { DatasetDeleteCall { hub: self.hub, _project_id: project_id.to_string(), @@ -1880,7 +1876,7 @@ impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `projectId` - Project ID of the new dataset - pub fn insert(&self, request: &Dataset, project_id: &str) -> DatasetInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Dataset, project_id: &str) -> DatasetInsertCall<'a, C, A> { DatasetInsertCall { hub: self.hub, _request: request.clone(), @@ -1922,15 +1918,15 @@ impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { /// let rb = hub.jobs(); /// # } /// ``` -pub struct JobMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct JobMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, } -impl<'a, C, NC, A> MethodsBuilder for JobMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for JobMethods<'a, C, A> {} -impl<'a, C, NC, A> JobMethods<'a, C, NC, A> { +impl<'a, C, A> JobMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1940,7 +1936,7 @@ impl<'a, C, NC, A> JobMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `projectId` - Project ID of the project billed for the query - pub fn query(&self, request: &QueryRequest, project_id: &str) -> JobQueryCall<'a, C, NC, A> { + pub fn query(&self, request: &QueryRequest, project_id: &str) -> JobQueryCall<'a, C, A> { JobQueryCall { hub: self.hub, _request: request.clone(), @@ -1959,7 +1955,7 @@ impl<'a, C, NC, A> JobMethods<'a, C, NC, A> { /// /// * `projectId` - Project ID of the query job /// * `jobId` - Job ID of the query job - pub fn get_query_results(&self, project_id: &str, job_id: &str) -> JobGetQueryResultCall<'a, C, NC, A> { + pub fn get_query_results(&self, project_id: &str, job_id: &str) -> JobGetQueryResultCall<'a, C, A> { JobGetQueryResultCall { hub: self.hub, _project_id: project_id.to_string(), @@ -1981,7 +1977,7 @@ impl<'a, C, NC, A> JobMethods<'a, C, NC, A> { /// # Arguments /// /// * `projectId` - Project ID of the jobs to list - pub fn list(&self, project_id: &str) -> JobListCall<'a, C, NC, A> { + pub fn list(&self, project_id: &str) -> JobListCall<'a, C, A> { JobListCall { hub: self.hub, _project_id: project_id.to_string(), @@ -2004,7 +2000,7 @@ impl<'a, C, NC, A> JobMethods<'a, C, NC, A> { /// /// * `projectId` - Project ID of the requested job /// * `jobId` - Job ID of the requested job - pub fn get(&self, project_id: &str, job_id: &str) -> JobGetCall<'a, C, NC, A> { + pub fn get(&self, project_id: &str, job_id: &str) -> JobGetCall<'a, C, A> { JobGetCall { hub: self.hub, _project_id: project_id.to_string(), @@ -2023,7 +2019,7 @@ impl<'a, C, NC, A> JobMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `projectId` - Project ID of the project that will be billed for the job - pub fn insert(&self, request: &Job, project_id: &str) -> JobInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Job, project_id: &str) -> JobInsertCall<'a, C, A> { JobInsertCall { hub: self.hub, _request: request.clone(), @@ -2065,15 +2061,15 @@ impl<'a, C, NC, A> JobMethods<'a, C, NC, A> { /// let rb = hub.tabledata(); /// # } /// ``` -pub struct TabledataMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TabledataMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, } -impl<'a, C, NC, A> MethodsBuilder for TabledataMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TabledataMethods<'a, C, A> {} -impl<'a, C, NC, A> TabledataMethods<'a, C, NC, A> { +impl<'a, C, A> TabledataMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2085,7 +2081,7 @@ impl<'a, C, NC, A> TabledataMethods<'a, C, NC, A> { /// * `projectId` - Project ID of the destination table. /// * `datasetId` - Dataset ID of the destination table. /// * `tableId` - Table ID of the destination table. - pub fn insert_all(&self, request: &TableDataInsertAllRequest, project_id: &str, dataset_id: &str, table_id: &str) -> TabledataInsertAllCall<'a, C, NC, A> { + pub fn insert_all(&self, request: &TableDataInsertAllRequest, project_id: &str, dataset_id: &str, table_id: &str) -> TabledataInsertAllCall<'a, C, A> { TabledataInsertAllCall { hub: self.hub, _request: request.clone(), @@ -2107,7 +2103,7 @@ impl<'a, C, NC, A> TabledataMethods<'a, C, NC, A> { /// * `projectId` - Project ID of the table to read /// * `datasetId` - Dataset ID of the table to read /// * `tableId` - Table ID of the table to read - pub fn list(&self, project_id: &str, dataset_id: &str, table_id: &str) -> TabledataListCall<'a, C, NC, A> { + pub fn list(&self, project_id: &str, dataset_id: &str, table_id: &str) -> TabledataListCall<'a, C, A> { TabledataListCall { hub: self.hub, _project_id: project_id.to_string(), @@ -2153,20 +2149,20 @@ impl<'a, C, NC, A> TabledataMethods<'a, C, NC, A> { /// let rb = hub.projects(); /// # } /// ``` -pub struct ProjectMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, } -impl<'a, C, NC, A> MethodsBuilder for ProjectMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ProjectMethods<'a, C, A> {} -impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { +impl<'a, C, A> ProjectMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Lists the projects to which you have at least read access. - pub fn list(&self) -> ProjectListCall<'a, C, NC, A> { + pub fn list(&self) -> ProjectListCall<'a, C, A> { ProjectListCall { hub: self.hub, _page_token: Default::default(), @@ -2222,10 +2218,10 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct TableUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, _request: Table, _project_id: String, _dataset_id: String, @@ -2235,9 +2231,9 @@ pub struct TableUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> TableUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2378,7 +2374,7 @@ impl<'a, C, NC, A> TableUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Table) -> TableUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Table) -> TableUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2388,7 +2384,7 @@ impl<'a, C, NC, A> TableUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Project ID of the table to update - pub fn project_id(mut self, new_value: &str) -> TableUpdateCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> TableUpdateCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -2398,7 +2394,7 @@ impl<'a, C, NC, A> TableUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Dataset ID of the table to update - pub fn dataset_id(mut self, new_value: &str) -> TableUpdateCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> TableUpdateCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -2408,7 +2404,7 @@ impl<'a, C, NC, A> TableUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Table ID of the table to update - pub fn table_id(mut self, new_value: &str) -> TableUpdateCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> TableUpdateCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -2419,7 +2415,7 @@ impl<'a, C, NC, A> TableUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2440,7 +2436,7 @@ impl<'a, C, NC, A> TableUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2457,7 +2453,7 @@ impl<'a, C, NC, A> TableUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2501,10 +2497,10 @@ impl<'a, C, NC, A> TableUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct TableInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, _request: Table, _project_id: String, _dataset_id: String, @@ -2513,9 +2509,9 @@ pub struct TableInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableInsertCall<'a, C, A> {} -impl<'a, C, NC, A> TableInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2655,7 +2651,7 @@ impl<'a, C, NC, A> TableInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Table) -> TableInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Table) -> TableInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2665,7 +2661,7 @@ impl<'a, C, NC, A> TableInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Project ID of the new table - pub fn project_id(mut self, new_value: &str) -> TableInsertCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> TableInsertCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -2675,7 +2671,7 @@ impl<'a, C, NC, A> TableInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Dataset ID of the new table - pub fn dataset_id(mut self, new_value: &str) -> TableInsertCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> TableInsertCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -2686,7 +2682,7 @@ impl<'a, C, NC, A> TableInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2707,7 +2703,7 @@ impl<'a, C, NC, A> TableInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2724,7 +2720,7 @@ impl<'a, C, NC, A> TableInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2764,10 +2760,10 @@ impl<'a, C, NC, A> TableInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct TableListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, _project_id: String, _dataset_id: String, _page_token: Option, @@ -2777,9 +2773,9 @@ pub struct TableListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableListCall<'a, C, A> {} -impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2918,7 +2914,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Project ID of the tables to list - pub fn project_id(mut self, new_value: &str) -> TableListCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> TableListCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -2928,7 +2924,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Dataset ID of the tables to list - pub fn dataset_id(mut self, new_value: &str) -> TableListCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> TableListCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -2936,7 +2932,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Page token, returned by a previous call, to request the next page of results - pub fn page_token(mut self, new_value: &str) -> TableListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TableListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2944,7 +2940,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Maximum number of results to return - pub fn max_results(mut self, new_value: u32) -> TableListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> TableListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2955,7 +2951,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2976,7 +2972,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2993,7 +2989,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3031,10 +3027,10 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct TableDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, _project_id: String, _dataset_id: String, _table_id: String, @@ -3043,9 +3039,9 @@ pub struct TableDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> TableDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3168,7 +3164,7 @@ impl<'a, C, NC, A> TableDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Project ID of the table to delete - pub fn project_id(mut self, new_value: &str) -> TableDeleteCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> TableDeleteCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -3178,7 +3174,7 @@ impl<'a, C, NC, A> TableDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Dataset ID of the table to delete - pub fn dataset_id(mut self, new_value: &str) -> TableDeleteCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> TableDeleteCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -3188,7 +3184,7 @@ impl<'a, C, NC, A> TableDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Table ID of the table to delete - pub fn table_id(mut self, new_value: &str) -> TableDeleteCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> TableDeleteCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -3199,7 +3195,7 @@ impl<'a, C, NC, A> TableDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3220,7 +3216,7 @@ impl<'a, C, NC, A> TableDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3237,7 +3233,7 @@ impl<'a, C, NC, A> TableDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3275,10 +3271,10 @@ impl<'a, C, NC, A> TableDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct TableGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, _project_id: String, _dataset_id: String, _table_id: String, @@ -3287,9 +3283,9 @@ pub struct TableGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableGetCall<'a, C, A> {} -impl<'a, C, NC, A> TableGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3423,7 +3419,7 @@ impl<'a, C, NC, A> TableGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Project ID of the requested table - pub fn project_id(mut self, new_value: &str) -> TableGetCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> TableGetCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -3433,7 +3429,7 @@ impl<'a, C, NC, A> TableGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Dataset ID of the requested table - pub fn dataset_id(mut self, new_value: &str) -> TableGetCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> TableGetCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -3443,7 +3439,7 @@ impl<'a, C, NC, A> TableGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Table ID of the requested table - pub fn table_id(mut self, new_value: &str) -> TableGetCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> TableGetCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -3454,7 +3450,7 @@ impl<'a, C, NC, A> TableGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3475,7 +3471,7 @@ impl<'a, C, NC, A> TableGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3492,7 +3488,7 @@ impl<'a, C, NC, A> TableGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3536,10 +3532,10 @@ impl<'a, C, NC, A> TableGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct TablePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TablePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, _request: Table, _project_id: String, _dataset_id: String, @@ -3549,9 +3545,9 @@ pub struct TablePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TablePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TablePatchCall<'a, C, A> {} -impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TablePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3692,7 +3688,7 @@ impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Table) -> TablePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Table) -> TablePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3702,7 +3698,7 @@ impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Project ID of the table to update - pub fn project_id(mut self, new_value: &str) -> TablePatchCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> TablePatchCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -3712,7 +3708,7 @@ impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Dataset ID of the table to update - pub fn dataset_id(mut self, new_value: &str) -> TablePatchCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> TablePatchCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -3722,7 +3718,7 @@ impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Table ID of the table to update - pub fn table_id(mut self, new_value: &str) -> TablePatchCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> TablePatchCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -3733,7 +3729,7 @@ impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TablePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TablePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3754,7 +3750,7 @@ impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TablePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TablePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3771,7 +3767,7 @@ impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TablePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TablePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3815,10 +3811,10 @@ impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct DatasetPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatasetPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, _request: Dataset, _project_id: String, _dataset_id: String, @@ -3827,9 +3823,9 @@ pub struct DatasetPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatasetPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatasetPatchCall<'a, C, A> {} -impl<'a, C, NC, A> DatasetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatasetPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3969,7 +3965,7 @@ impl<'a, C, NC, A> DatasetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Dataset) -> DatasetPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Dataset) -> DatasetPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3979,7 +3975,7 @@ impl<'a, C, NC, A> DatasetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Project ID of the dataset being updated - pub fn project_id(mut self, new_value: &str) -> DatasetPatchCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> DatasetPatchCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -3989,7 +3985,7 @@ impl<'a, C, NC, A> DatasetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Dataset ID of the dataset being updated - pub fn dataset_id(mut self, new_value: &str) -> DatasetPatchCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> DatasetPatchCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -4000,7 +3996,7 @@ impl<'a, C, NC, A> DatasetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4021,7 +4017,7 @@ impl<'a, C, NC, A> DatasetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatasetPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatasetPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4038,7 +4034,7 @@ impl<'a, C, NC, A> DatasetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatasetPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatasetPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4076,10 +4072,10 @@ impl<'a, C, NC, A> DatasetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct DatasetGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatasetGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, _project_id: String, _dataset_id: String, _delegate: Option<&'a mut Delegate>, @@ -4087,9 +4083,9 @@ pub struct DatasetGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatasetGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatasetGetCall<'a, C, A> {} -impl<'a, C, NC, A> DatasetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatasetGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4222,7 +4218,7 @@ impl<'a, C, NC, A> DatasetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Project ID of the requested dataset - pub fn project_id(mut self, new_value: &str) -> DatasetGetCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> DatasetGetCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -4232,7 +4228,7 @@ impl<'a, C, NC, A> DatasetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Dataset ID of the requested dataset - pub fn dataset_id(mut self, new_value: &str) -> DatasetGetCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> DatasetGetCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -4243,7 +4239,7 @@ impl<'a, C, NC, A> DatasetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4264,7 +4260,7 @@ impl<'a, C, NC, A> DatasetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatasetGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatasetGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4281,7 +4277,7 @@ impl<'a, C, NC, A> DatasetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatasetGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatasetGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4322,10 +4318,10 @@ impl<'a, C, NC, A> DatasetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct DatasetListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatasetListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, _project_id: String, _page_token: Option, _max_results: Option, @@ -4335,9 +4331,9 @@ pub struct DatasetListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatasetListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatasetListCall<'a, C, A> {} -impl<'a, C, NC, A> DatasetListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatasetListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4478,7 +4474,7 @@ impl<'a, C, NC, A> DatasetListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Project ID of the datasets to be listed - pub fn project_id(mut self, new_value: &str) -> DatasetListCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> DatasetListCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -4486,7 +4482,7 @@ impl<'a, C, NC, A> DatasetListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Page token, returned by a previous call, to request the next page of results - pub fn page_token(mut self, new_value: &str) -> DatasetListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> DatasetListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -4494,7 +4490,7 @@ impl<'a, C, NC, A> DatasetListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The maximum number of results to return - pub fn max_results(mut self, new_value: u32) -> DatasetListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> DatasetListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -4502,7 +4498,7 @@ impl<'a, C, NC, A> DatasetListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Whether to list all datasets, including hidden ones - pub fn all(mut self, new_value: bool) -> DatasetListCall<'a, C, NC, A> { + pub fn all(mut self, new_value: bool) -> DatasetListCall<'a, C, A> { self._all = Some(new_value); self } @@ -4513,7 +4509,7 @@ impl<'a, C, NC, A> DatasetListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4534,7 +4530,7 @@ impl<'a, C, NC, A> DatasetListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatasetListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatasetListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4551,7 +4547,7 @@ impl<'a, C, NC, A> DatasetListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatasetListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatasetListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4595,10 +4591,10 @@ impl<'a, C, NC, A> DatasetListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct DatasetUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatasetUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, _request: Dataset, _project_id: String, _dataset_id: String, @@ -4607,9 +4603,9 @@ pub struct DatasetUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatasetUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatasetUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> DatasetUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatasetUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4749,7 +4745,7 @@ impl<'a, C, NC, A> DatasetUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Dataset) -> DatasetUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Dataset) -> DatasetUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4759,7 +4755,7 @@ impl<'a, C, NC, A> DatasetUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Project ID of the dataset being updated - pub fn project_id(mut self, new_value: &str) -> DatasetUpdateCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> DatasetUpdateCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -4769,7 +4765,7 @@ impl<'a, C, NC, A> DatasetUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Dataset ID of the dataset being updated - pub fn dataset_id(mut self, new_value: &str) -> DatasetUpdateCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> DatasetUpdateCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -4780,7 +4776,7 @@ impl<'a, C, NC, A> DatasetUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4801,7 +4797,7 @@ impl<'a, C, NC, A> DatasetUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatasetUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatasetUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4818,7 +4814,7 @@ impl<'a, C, NC, A> DatasetUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatasetUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatasetUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4857,10 +4853,10 @@ impl<'a, C, NC, A> DatasetUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct DatasetDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatasetDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, _project_id: String, _dataset_id: String, _delete_contents: Option, @@ -4869,9 +4865,9 @@ pub struct DatasetDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatasetDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatasetDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> DatasetDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatasetDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4996,7 +4992,7 @@ impl<'a, C, NC, A> DatasetDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Project ID of the dataset being deleted - pub fn project_id(mut self, new_value: &str) -> DatasetDeleteCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> DatasetDeleteCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -5006,7 +5002,7 @@ impl<'a, C, NC, A> DatasetDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Dataset ID of dataset being deleted - pub fn dataset_id(mut self, new_value: &str) -> DatasetDeleteCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> DatasetDeleteCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -5014,7 +5010,7 @@ impl<'a, C, NC, A> DatasetDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// If True, delete all the tables in the dataset. If False and the dataset contains tables, the request will fail. Default is False - pub fn delete_contents(mut self, new_value: bool) -> DatasetDeleteCall<'a, C, NC, A> { + pub fn delete_contents(mut self, new_value: bool) -> DatasetDeleteCall<'a, C, A> { self._delete_contents = Some(new_value); self } @@ -5025,7 +5021,7 @@ impl<'a, C, NC, A> DatasetDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5046,7 +5042,7 @@ impl<'a, C, NC, A> DatasetDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatasetDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatasetDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5063,7 +5059,7 @@ impl<'a, C, NC, A> DatasetDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatasetDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatasetDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5107,10 +5103,10 @@ impl<'a, C, NC, A> DatasetDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct DatasetInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatasetInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, _request: Dataset, _project_id: String, _delegate: Option<&'a mut Delegate>, @@ -5118,9 +5114,9 @@ pub struct DatasetInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatasetInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatasetInsertCall<'a, C, A> {} -impl<'a, C, NC, A> DatasetInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatasetInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5259,7 +5255,7 @@ impl<'a, C, NC, A> DatasetInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Dataset) -> DatasetInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Dataset) -> DatasetInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5269,7 +5265,7 @@ impl<'a, C, NC, A> DatasetInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Project ID of the new dataset - pub fn project_id(mut self, new_value: &str) -> DatasetInsertCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> DatasetInsertCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -5280,7 +5276,7 @@ impl<'a, C, NC, A> DatasetInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5301,7 +5297,7 @@ impl<'a, C, NC, A> DatasetInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatasetInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatasetInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5318,7 +5314,7 @@ impl<'a, C, NC, A> DatasetInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatasetInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatasetInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5362,10 +5358,10 @@ impl<'a, C, NC, A> DatasetInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct JobQueryCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct JobQueryCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, _request: QueryRequest, _project_id: String, _delegate: Option<&'a mut Delegate>, @@ -5373,9 +5369,9 @@ pub struct JobQueryCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for JobQueryCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for JobQueryCall<'a, C, A> {} -impl<'a, C, NC, A> JobQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> JobQueryCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5514,7 +5510,7 @@ impl<'a, C, NC, A> JobQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &QueryRequest) -> JobQueryCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &QueryRequest) -> JobQueryCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5524,7 +5520,7 @@ impl<'a, C, NC, A> JobQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Project ID of the project billed for the query - pub fn project_id(mut self, new_value: &str) -> JobQueryCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> JobQueryCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -5535,7 +5531,7 @@ impl<'a, C, NC, A> JobQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobQueryCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobQueryCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5556,7 +5552,7 @@ impl<'a, C, NC, A> JobQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> JobQueryCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> JobQueryCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5573,7 +5569,7 @@ impl<'a, C, NC, A> JobQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> JobQueryCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> JobQueryCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5615,10 +5611,10 @@ impl<'a, C, NC, A> JobQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct JobGetQueryResultCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct JobGetQueryResultCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, _project_id: String, _job_id: String, _timeout_ms: Option, @@ -5630,9 +5626,9 @@ pub struct JobGetQueryResultCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for JobGetQueryResultCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for JobGetQueryResultCall<'a, C, A> {} -impl<'a, C, NC, A> JobGetQueryResultCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> JobGetQueryResultCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5777,7 +5773,7 @@ impl<'a, C, NC, A> JobGetQueryResultCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Project ID of the query job - pub fn project_id(mut self, new_value: &str) -> JobGetQueryResultCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> JobGetQueryResultCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -5787,7 +5783,7 @@ impl<'a, C, NC, A> JobGetQueryResultCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Job ID of the query job - pub fn job_id(mut self, new_value: &str) -> JobGetQueryResultCall<'a, C, NC, A> { + pub fn job_id(mut self, new_value: &str) -> JobGetQueryResultCall<'a, C, A> { self._job_id = new_value.to_string(); self } @@ -5795,7 +5791,7 @@ impl<'a, C, NC, A> JobGetQueryResultCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// How long to wait for the query to complete, in milliseconds, before returning. Default is to return immediately. If the timeout passes before the job completes, the request will fail with a TIMEOUT error - pub fn timeout_ms(mut self, new_value: u32) -> JobGetQueryResultCall<'a, C, NC, A> { + pub fn timeout_ms(mut self, new_value: u32) -> JobGetQueryResultCall<'a, C, A> { self._timeout_ms = Some(new_value); self } @@ -5803,7 +5799,7 @@ impl<'a, C, NC, A> JobGetQueryResultCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Zero-based index of the starting row - pub fn start_index(mut self, new_value: &str) -> JobGetQueryResultCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: &str) -> JobGetQueryResultCall<'a, C, A> { self._start_index = Some(new_value.to_string()); self } @@ -5811,7 +5807,7 @@ impl<'a, C, NC, A> JobGetQueryResultCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Page token, returned by a previous call, to request the next page of results - pub fn page_token(mut self, new_value: &str) -> JobGetQueryResultCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> JobGetQueryResultCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -5819,7 +5815,7 @@ impl<'a, C, NC, A> JobGetQueryResultCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Maximum number of results to read - pub fn max_results(mut self, new_value: u32) -> JobGetQueryResultCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> JobGetQueryResultCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -5830,7 +5826,7 @@ impl<'a, C, NC, A> JobGetQueryResultCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobGetQueryResultCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobGetQueryResultCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5851,7 +5847,7 @@ impl<'a, C, NC, A> JobGetQueryResultCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> JobGetQueryResultCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> JobGetQueryResultCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5868,7 +5864,7 @@ impl<'a, C, NC, A> JobGetQueryResultCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> JobGetQueryResultCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> JobGetQueryResultCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5911,10 +5907,10 @@ impl<'a, C, NC, A> JobGetQueryResultCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct JobListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct JobListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, _project_id: String, _state_filter: Vec, _projection: Option, @@ -5926,9 +5922,9 @@ pub struct JobListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for JobListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for JobListCall<'a, C, A> {} -impl<'a, C, NC, A> JobListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> JobListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6079,7 +6075,7 @@ impl<'a, C, NC, A> JobListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// Project ID of the jobs to list - pub fn project_id(mut self, new_value: &str) -> JobListCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> JobListCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -6088,7 +6084,7 @@ impl<'a, C, NC, A> JobListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Filter for job state - pub fn add_state_filter(mut self, new_value: &str) -> JobListCall<'a, C, NC, A> { + pub fn add_state_filter(mut self, new_value: &str) -> JobListCall<'a, C, A> { self._state_filter.push(new_value.to_string()); self } @@ -6096,7 +6092,7 @@ impl<'a, C, NC, A> JobListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Restrict information returned to a set of selected fields - pub fn projection(mut self, new_value: &str) -> JobListCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> JobListCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -6104,7 +6100,7 @@ impl<'a, C, NC, A> JobListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Page token, returned by a previous call, to request the next page of results - pub fn page_token(mut self, new_value: &str) -> JobListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> JobListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -6112,7 +6108,7 @@ impl<'a, C, NC, A> JobListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Maximum number of results to return - pub fn max_results(mut self, new_value: u32) -> JobListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> JobListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -6120,7 +6116,7 @@ impl<'a, C, NC, A> JobListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Whether to display jobs owned by all users in the project. Default false - pub fn all_users(mut self, new_value: bool) -> JobListCall<'a, C, NC, A> { + pub fn all_users(mut self, new_value: bool) -> JobListCall<'a, C, A> { self._all_users = Some(new_value); self } @@ -6131,7 +6127,7 @@ impl<'a, C, NC, A> JobListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6152,7 +6148,7 @@ impl<'a, C, NC, A> JobListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> JobListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> JobListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6169,7 +6165,7 @@ impl<'a, C, NC, A> JobListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> JobListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> JobListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6207,10 +6203,10 @@ impl<'a, C, NC, A> JobListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct JobGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct JobGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, _project_id: String, _job_id: String, _delegate: Option<&'a mut Delegate>, @@ -6218,9 +6214,9 @@ pub struct JobGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for JobGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for JobGetCall<'a, C, A> {} -impl<'a, C, NC, A> JobGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> JobGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6353,7 +6349,7 @@ impl<'a, C, NC, A> JobGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// we provide this method for API completeness. /// /// Project ID of the requested job - pub fn project_id(mut self, new_value: &str) -> JobGetCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> JobGetCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -6363,7 +6359,7 @@ impl<'a, C, NC, A> JobGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// we provide this method for API completeness. /// /// Job ID of the requested job - pub fn job_id(mut self, new_value: &str) -> JobGetCall<'a, C, NC, A> { + pub fn job_id(mut self, new_value: &str) -> JobGetCall<'a, C, A> { self._job_id = new_value.to_string(); self } @@ -6374,7 +6370,7 @@ impl<'a, C, NC, A> JobGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6395,7 +6391,7 @@ impl<'a, C, NC, A> JobGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> JobGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> JobGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6412,7 +6408,7 @@ impl<'a, C, NC, A> JobGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> JobGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> JobGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6457,10 +6453,10 @@ impl<'a, C, NC, A> JobGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// .upload(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct JobInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct JobInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, _request: Job, _project_id: String, _delegate: Option<&'a mut Delegate>, @@ -6468,9 +6464,9 @@ pub struct JobInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for JobInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for JobInsertCall<'a, C, A> {} -impl<'a, C, NC, A> JobInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> JobInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6719,7 +6715,7 @@ impl<'a, C, NC, A> JobInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Job) -> JobInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Job) -> JobInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6729,7 +6725,7 @@ impl<'a, C, NC, A> JobInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Project ID of the project that will be billed for the job - pub fn project_id(mut self, new_value: &str) -> JobInsertCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> JobInsertCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -6740,7 +6736,7 @@ impl<'a, C, NC, A> JobInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6761,7 +6757,7 @@ impl<'a, C, NC, A> JobInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> JobInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> JobInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6778,7 +6774,7 @@ impl<'a, C, NC, A> JobInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> JobInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> JobInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6822,10 +6818,10 @@ impl<'a, C, NC, A> JobInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct TabledataInsertAllCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TabledataInsertAllCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, _request: TableDataInsertAllRequest, _project_id: String, _dataset_id: String, @@ -6835,9 +6831,9 @@ pub struct TabledataInsertAllCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TabledataInsertAllCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TabledataInsertAllCall<'a, C, A> {} -impl<'a, C, NC, A> TabledataInsertAllCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TabledataInsertAllCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6978,7 +6974,7 @@ impl<'a, C, NC, A> TabledataInsertAllCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &TableDataInsertAllRequest) -> TabledataInsertAllCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &TableDataInsertAllRequest) -> TabledataInsertAllCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6988,7 +6984,7 @@ impl<'a, C, NC, A> TabledataInsertAllCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Project ID of the destination table. - pub fn project_id(mut self, new_value: &str) -> TabledataInsertAllCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> TabledataInsertAllCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -6998,7 +6994,7 @@ impl<'a, C, NC, A> TabledataInsertAllCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Dataset ID of the destination table. - pub fn dataset_id(mut self, new_value: &str) -> TabledataInsertAllCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> TabledataInsertAllCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -7008,7 +7004,7 @@ impl<'a, C, NC, A> TabledataInsertAllCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Table ID of the destination table. - pub fn table_id(mut self, new_value: &str) -> TabledataInsertAllCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> TabledataInsertAllCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -7019,7 +7015,7 @@ impl<'a, C, NC, A> TabledataInsertAllCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TabledataInsertAllCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TabledataInsertAllCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7040,7 +7036,7 @@ impl<'a, C, NC, A> TabledataInsertAllCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TabledataInsertAllCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TabledataInsertAllCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7057,7 +7053,7 @@ impl<'a, C, NC, A> TabledataInsertAllCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TabledataInsertAllCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TabledataInsertAllCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7098,10 +7094,10 @@ impl<'a, C, NC, A> TabledataInsertAllCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct TabledataListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TabledataListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, _project_id: String, _dataset_id: String, _table_id: String, @@ -7113,9 +7109,9 @@ pub struct TabledataListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TabledataListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TabledataListCall<'a, C, A> {} -impl<'a, C, NC, A> TabledataListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TabledataListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7258,7 +7254,7 @@ impl<'a, C, NC, A> TabledataListCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Project ID of the table to read - pub fn project_id(mut self, new_value: &str) -> TabledataListCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> TabledataListCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -7268,7 +7264,7 @@ impl<'a, C, NC, A> TabledataListCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Dataset ID of the table to read - pub fn dataset_id(mut self, new_value: &str) -> TabledataListCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> TabledataListCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -7278,7 +7274,7 @@ impl<'a, C, NC, A> TabledataListCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Table ID of the table to read - pub fn table_id(mut self, new_value: &str) -> TabledataListCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> TabledataListCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -7286,7 +7282,7 @@ impl<'a, C, NC, A> TabledataListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Zero-based index of the starting row to read - pub fn start_index(mut self, new_value: &str) -> TabledataListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: &str) -> TabledataListCall<'a, C, A> { self._start_index = Some(new_value.to_string()); self } @@ -7294,7 +7290,7 @@ impl<'a, C, NC, A> TabledataListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Page token, returned by a previous call, identifying the result set - pub fn page_token(mut self, new_value: &str) -> TabledataListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TabledataListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -7302,7 +7298,7 @@ impl<'a, C, NC, A> TabledataListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Maximum number of results to return - pub fn max_results(mut self, new_value: u32) -> TabledataListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> TabledataListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -7313,7 +7309,7 @@ impl<'a, C, NC, A> TabledataListCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TabledataListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TabledataListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7334,7 +7330,7 @@ impl<'a, C, NC, A> TabledataListCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TabledataListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TabledataListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7351,7 +7347,7 @@ impl<'a, C, NC, A> TabledataListCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TabledataListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TabledataListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7391,10 +7387,10 @@ impl<'a, C, NC, A> TabledataListCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct ProjectListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Bigquery, + hub: &'a Bigquery, _page_token: Option, _max_results: Option, _delegate: Option<&'a mut Delegate>, @@ -7402,9 +7398,9 @@ pub struct ProjectListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectListCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7515,7 +7511,7 @@ impl<'a, C, NC, A> ProjectListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Page token, returned by a previous call, to request the next page of results - pub fn page_token(mut self, new_value: &str) -> ProjectListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ProjectListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -7523,7 +7519,7 @@ impl<'a, C, NC, A> ProjectListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Maximum number of results to return - pub fn max_results(mut self, new_value: u32) -> ProjectListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> ProjectListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -7534,7 +7530,7 @@ impl<'a, C, NC, A> ProjectListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7555,7 +7551,7 @@ impl<'a, C, NC, A> ProjectListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7572,7 +7568,7 @@ impl<'a, C, NC, A> ProjectListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/blogger3/Cargo.toml b/gen/blogger3/Cargo.toml index ed8e96ca241..0ddddd41107 100644 --- a/gen/blogger3/Cargo.toml +++ b/gen/blogger3/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-blogger3" -version = "0.1.4+20150208" +version = "0.1.5+20150208" authors = ["Sebastian Thiel "] description = "A complete library to interact with blogger (protocol v3)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/blogger3" homepage = "https://developers.google.com/blogger/docs/3.0/getting_started" -documentation = "http://byron.github.io/google-apis-rs/google-blogger3" +documentation = "http://byron.github.io/google-apis-rs/google_blogger3" license = "MIT" keywords = ["blogger", "google", "protocol", "web", "api"] diff --git a/gen/blogger3/README.md b/gen/blogger3/README.md index f2c3c2799db..c4375a188bb 100644 --- a/gen/blogger3/README.md +++ b/gen/blogger3/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-blogger3` library allows access to all features of the *Google blogger* service. -This documentation was generated from *blogger* crate version *0.1.4+20150208*, where *20150208* is the exact revision of the *blogger:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *blogger* crate version *0.1.5+20150208*, where *20150208* is the exact revision of the *blogger:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *blogger* *v3* API can be found at the [official documentation site](https://developers.google.com/blogger/docs/3.0/getting_started). diff --git a/gen/blogger3/src/cmn.rs b/gen/blogger3/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/blogger3/src/cmn.rs +++ b/gen/blogger3/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/blogger3/src/lib.rs b/gen/blogger3/src/lib.rs index 64f769e75a7..3f5289ca482 100644 --- a/gen/blogger3/src/lib.rs +++ b/gen/blogger3/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *blogger* crate version *0.1.4+20150208*, where *20150208* is the exact revision of the *blogger:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *blogger* crate version *0.1.5+20150208*, where *20150208* is the exact revision of the *blogger:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *blogger* *v3* API can be found at the //! [official documentation site](https://developers.google.com/blogger/docs/3.0/getting_started). @@ -221,7 +221,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -326,55 +325,52 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Blogger { +pub struct Blogger { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Blogger {} +impl<'a, C, A> Hub for Blogger {} -impl<'a, C, NC, A> Blogger - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Blogger + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Blogger { + pub fn new(client: C, authenticator: A) -> Blogger { Blogger { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn blog_user_infos(&'a self) -> BlogUserInfoMethods<'a, C, NC, A> { + pub fn blog_user_infos(&'a self) -> BlogUserInfoMethods<'a, C, A> { BlogUserInfoMethods { hub: &self } } - pub fn blogs(&'a self) -> BlogMethods<'a, C, NC, A> { + pub fn blogs(&'a self) -> BlogMethods<'a, C, A> { BlogMethods { hub: &self } } - pub fn comments(&'a self) -> CommentMethods<'a, C, NC, A> { + pub fn comments(&'a self) -> CommentMethods<'a, C, A> { CommentMethods { hub: &self } } - pub fn page_views(&'a self) -> PageViewMethods<'a, C, NC, A> { + pub fn page_views(&'a self) -> PageViewMethods<'a, C, A> { PageViewMethods { hub: &self } } - pub fn pages(&'a self) -> PageMethods<'a, C, NC, A> { + pub fn pages(&'a self) -> PageMethods<'a, C, A> { PageMethods { hub: &self } } - pub fn post_user_infos(&'a self) -> PostUserInfoMethods<'a, C, NC, A> { + pub fn post_user_infos(&'a self) -> PostUserInfoMethods<'a, C, A> { PostUserInfoMethods { hub: &self } } - pub fn posts(&'a self) -> PostMethods<'a, C, NC, A> { + pub fn posts(&'a self) -> PostMethods<'a, C, A> { PostMethods { hub: &self } } - pub fn users(&'a self) -> UserMethods<'a, C, NC, A> { + pub fn users(&'a self) -> UserMethods<'a, C, A> { UserMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -1248,15 +1244,15 @@ impl Part for BlogLocale {} /// let rb = hub.page_views(); /// # } /// ``` -pub struct PageViewMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PageViewMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, } -impl<'a, C, NC, A> MethodsBuilder for PageViewMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PageViewMethods<'a, C, A> {} -impl<'a, C, NC, A> PageViewMethods<'a, C, NC, A> { +impl<'a, C, A> PageViewMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1265,7 +1261,7 @@ impl<'a, C, NC, A> PageViewMethods<'a, C, NC, A> { /// # Arguments /// /// * `blogId` - The ID of the blog to get. - pub fn get(&self, blog_id: &str) -> PageViewGetCall<'a, C, NC, A> { + pub fn get(&self, blog_id: &str) -> PageViewGetCall<'a, C, A> { PageViewGetCall { hub: self.hub, _blog_id: blog_id.to_string(), @@ -1307,15 +1303,15 @@ impl<'a, C, NC, A> PageViewMethods<'a, C, NC, A> { /// let rb = hub.users(); /// # } /// ``` -pub struct UserMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, } -impl<'a, C, NC, A> MethodsBuilder for UserMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for UserMethods<'a, C, A> {} -impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { +impl<'a, C, A> UserMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1324,7 +1320,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// # Arguments /// /// * `userId` - The ID of the user to get. - pub fn get(&self, user_id: &str) -> UserGetCall<'a, C, NC, A> { + pub fn get(&self, user_id: &str) -> UserGetCall<'a, C, A> { UserGetCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1365,15 +1361,15 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// let rb = hub.blogs(); /// # } /// ``` -pub struct BlogMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BlogMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, } -impl<'a, C, NC, A> MethodsBuilder for BlogMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for BlogMethods<'a, C, A> {} -impl<'a, C, NC, A> BlogMethods<'a, C, NC, A> { +impl<'a, C, A> BlogMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1382,7 +1378,7 @@ impl<'a, C, NC, A> BlogMethods<'a, C, NC, A> { /// # Arguments /// /// * `userId` - ID of the user whose blogs are to be fetched. Either the word 'self' (sans quote marks) or the user's profile identifier. - pub fn list_by_user(&self, user_id: &str) -> BlogListByUserCall<'a, C, NC, A> { + pub fn list_by_user(&self, user_id: &str) -> BlogListByUserCall<'a, C, A> { BlogListByUserCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1403,7 +1399,7 @@ impl<'a, C, NC, A> BlogMethods<'a, C, NC, A> { /// # Arguments /// /// * `blogId` - The ID of the blog to get. - pub fn get(&self, blog_id: &str) -> BlogGetCall<'a, C, NC, A> { + pub fn get(&self, blog_id: &str) -> BlogGetCall<'a, C, A> { BlogGetCall { hub: self.hub, _blog_id: blog_id.to_string(), @@ -1422,7 +1418,7 @@ impl<'a, C, NC, A> BlogMethods<'a, C, NC, A> { /// # Arguments /// /// * `url` - The URL of the blog to retrieve. - pub fn get_by_url(&self, url: &str) -> BlogGetByUrlCall<'a, C, NC, A> { + pub fn get_by_url(&self, url: &str) -> BlogGetByUrlCall<'a, C, A> { BlogGetByUrlCall { hub: self.hub, _url: url.to_string(), @@ -1464,15 +1460,15 @@ impl<'a, C, NC, A> BlogMethods<'a, C, NC, A> { /// let rb = hub.posts(); /// # } /// ``` -pub struct PostMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PostMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, } -impl<'a, C, NC, A> MethodsBuilder for PostMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PostMethods<'a, C, A> {} -impl<'a, C, NC, A> PostMethods<'a, C, NC, A> { +impl<'a, C, A> PostMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1483,7 +1479,7 @@ impl<'a, C, NC, A> PostMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `blogId` - The ID of the Blog. /// * `postId` - The ID of the Post. - pub fn update(&self, request: &Post, blog_id: &str, post_id: &str) -> PostUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Post, blog_id: &str, post_id: &str) -> PostUpdateCall<'a, C, A> { PostUpdateCall { hub: self.hub, _request: request.clone(), @@ -1508,7 +1504,7 @@ impl<'a, C, NC, A> PostMethods<'a, C, NC, A> { /// /// * `blogId` - ID of the blog to fetch the post from. /// * `path` - Path of the Post to retrieve. - pub fn get_by_path(&self, blog_id: &str, path: &str) -> PostGetByPathCall<'a, C, NC, A> { + pub fn get_by_path(&self, blog_id: &str, path: &str) -> PostGetByPathCall<'a, C, A> { PostGetByPathCall { hub: self.hub, _blog_id: blog_id.to_string(), @@ -1529,7 +1525,7 @@ impl<'a, C, NC, A> PostMethods<'a, C, NC, A> { /// /// * `blogId` - ID of the blog to fetch the post from. /// * `postId` - The ID of the post - pub fn get(&self, blog_id: &str, post_id: &str) -> PostGetCall<'a, C, NC, A> { + pub fn get(&self, blog_id: &str, post_id: &str) -> PostGetCall<'a, C, A> { PostGetCall { hub: self.hub, _blog_id: blog_id.to_string(), @@ -1552,7 +1548,7 @@ impl<'a, C, NC, A> PostMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `blogId` - ID of the blog to add the post to. - pub fn insert(&self, request: &Post, blog_id: &str) -> PostInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Post, blog_id: &str) -> PostInsertCall<'a, C, A> { PostInsertCall { hub: self.hub, _request: request.clone(), @@ -1574,7 +1570,7 @@ impl<'a, C, NC, A> PostMethods<'a, C, NC, A> { /// /// * `blogId` - The ID of the Blog. /// * `postId` - The ID of the Post. - pub fn publish(&self, blog_id: &str, post_id: &str) -> PostPublishCall<'a, C, NC, A> { + pub fn publish(&self, blog_id: &str, post_id: &str) -> PostPublishCall<'a, C, A> { PostPublishCall { hub: self.hub, _blog_id: blog_id.to_string(), @@ -1594,7 +1590,7 @@ impl<'a, C, NC, A> PostMethods<'a, C, NC, A> { /// /// * `blogId` - The ID of the Blog. /// * `postId` - The ID of the Post. - pub fn delete(&self, blog_id: &str, post_id: &str) -> PostDeleteCall<'a, C, NC, A> { + pub fn delete(&self, blog_id: &str, post_id: &str) -> PostDeleteCall<'a, C, A> { PostDeleteCall { hub: self.hub, _blog_id: blog_id.to_string(), @@ -1613,7 +1609,7 @@ impl<'a, C, NC, A> PostMethods<'a, C, NC, A> { /// /// * `blogId` - The ID of the Blog. /// * `postId` - The ID of the Post. - pub fn revert(&self, blog_id: &str, post_id: &str) -> PostRevertCall<'a, C, NC, A> { + pub fn revert(&self, blog_id: &str, post_id: &str) -> PostRevertCall<'a, C, A> { PostRevertCall { hub: self.hub, _blog_id: blog_id.to_string(), @@ -1632,7 +1628,7 @@ impl<'a, C, NC, A> PostMethods<'a, C, NC, A> { /// /// * `blogId` - ID of the blog to fetch the post from. /// * `q` - Query terms to search this blog for matching posts. - pub fn search(&self, blog_id: &str, q: &str) -> PostSearchCall<'a, C, NC, A> { + pub fn search(&self, blog_id: &str, q: &str) -> PostSearchCall<'a, C, A> { PostSearchCall { hub: self.hub, _blog_id: blog_id.to_string(), @@ -1654,7 +1650,7 @@ impl<'a, C, NC, A> PostMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `blogId` - The ID of the Blog. /// * `postId` - The ID of the Post. - pub fn patch(&self, request: &Post, blog_id: &str, post_id: &str) -> PostPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Post, blog_id: &str, post_id: &str) -> PostPatchCall<'a, C, A> { PostPatchCall { hub: self.hub, _request: request.clone(), @@ -1678,7 +1674,7 @@ impl<'a, C, NC, A> PostMethods<'a, C, NC, A> { /// # Arguments /// /// * `blogId` - ID of the blog to fetch posts from. - pub fn list(&self, blog_id: &str) -> PostListCall<'a, C, NC, A> { + pub fn list(&self, blog_id: &str) -> PostListCall<'a, C, A> { PostListCall { hub: self.hub, _blog_id: blog_id.to_string(), @@ -1729,15 +1725,15 @@ impl<'a, C, NC, A> PostMethods<'a, C, NC, A> { /// let rb = hub.comments(); /// # } /// ``` -pub struct CommentMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CommentMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, } -impl<'a, C, NC, A> MethodsBuilder for CommentMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CommentMethods<'a, C, A> {} -impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { +impl<'a, C, A> CommentMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1748,7 +1744,7 @@ impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { /// * `blogId` - ID of the blog to containing the comment. /// * `postId` - ID of the post to fetch posts from. /// * `commentId` - The ID of the comment to get. - pub fn get(&self, blog_id: &str, post_id: &str, comment_id: &str) -> CommentGetCall<'a, C, NC, A> { + pub fn get(&self, blog_id: &str, post_id: &str, comment_id: &str) -> CommentGetCall<'a, C, A> { CommentGetCall { hub: self.hub, _blog_id: blog_id.to_string(), @@ -1770,7 +1766,7 @@ impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { /// * `blogId` - The ID of the Blog. /// * `postId` - The ID of the Post. /// * `commentId` - The ID of the comment to delete content from. - pub fn remove_content(&self, blog_id: &str, post_id: &str, comment_id: &str) -> CommentRemoveContentCall<'a, C, NC, A> { + pub fn remove_content(&self, blog_id: &str, post_id: &str, comment_id: &str) -> CommentRemoveContentCall<'a, C, A> { CommentRemoveContentCall { hub: self.hub, _blog_id: blog_id.to_string(), @@ -1789,7 +1785,7 @@ impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { /// # Arguments /// /// * `blogId` - ID of the blog to fetch comments from. - pub fn list_by_blog(&self, blog_id: &str) -> CommentListByBlogCall<'a, C, NC, A> { + pub fn list_by_blog(&self, blog_id: &str) -> CommentListByBlogCall<'a, C, A> { CommentListByBlogCall { hub: self.hub, _blog_id: blog_id.to_string(), @@ -1814,7 +1810,7 @@ impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { /// * `blogId` - The ID of the Blog. /// * `postId` - The ID of the Post. /// * `commentId` - The ID of the comment to mark as spam. - pub fn mark_as_spam(&self, blog_id: &str, post_id: &str, comment_id: &str) -> CommentMarkAsSpamCall<'a, C, NC, A> { + pub fn mark_as_spam(&self, blog_id: &str, post_id: &str, comment_id: &str) -> CommentMarkAsSpamCall<'a, C, A> { CommentMarkAsSpamCall { hub: self.hub, _blog_id: blog_id.to_string(), @@ -1834,7 +1830,7 @@ impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { /// /// * `blogId` - ID of the blog to fetch comments from. /// * `postId` - ID of the post to fetch posts from. - pub fn list(&self, blog_id: &str, post_id: &str) -> CommentListCall<'a, C, NC, A> { + pub fn list(&self, blog_id: &str, post_id: &str) -> CommentListCall<'a, C, A> { CommentListCall { hub: self.hub, _blog_id: blog_id.to_string(), @@ -1861,7 +1857,7 @@ impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { /// * `blogId` - The ID of the Blog. /// * `postId` - The ID of the Post. /// * `commentId` - The ID of the comment to mark as not spam. - pub fn approve(&self, blog_id: &str, post_id: &str, comment_id: &str) -> CommentApproveCall<'a, C, NC, A> { + pub fn approve(&self, blog_id: &str, post_id: &str, comment_id: &str) -> CommentApproveCall<'a, C, A> { CommentApproveCall { hub: self.hub, _blog_id: blog_id.to_string(), @@ -1882,7 +1878,7 @@ impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { /// * `blogId` - The ID of the Blog. /// * `postId` - The ID of the Post. /// * `commentId` - The ID of the comment to delete. - pub fn delete(&self, blog_id: &str, post_id: &str, comment_id: &str) -> CommentDeleteCall<'a, C, NC, A> { + pub fn delete(&self, blog_id: &str, post_id: &str, comment_id: &str) -> CommentDeleteCall<'a, C, A> { CommentDeleteCall { hub: self.hub, _blog_id: blog_id.to_string(), @@ -1925,15 +1921,15 @@ impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { /// let rb = hub.post_user_infos(); /// # } /// ``` -pub struct PostUserInfoMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PostUserInfoMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, } -impl<'a, C, NC, A> MethodsBuilder for PostUserInfoMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PostUserInfoMethods<'a, C, A> {} -impl<'a, C, NC, A> PostUserInfoMethods<'a, C, NC, A> { +impl<'a, C, A> PostUserInfoMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1944,7 +1940,7 @@ impl<'a, C, NC, A> PostUserInfoMethods<'a, C, NC, A> { /// * `userId` - ID of the user for the per-user information to be fetched. Either the word 'self' (sans quote marks) or the user's profile identifier. /// * `blogId` - The ID of the blog. /// * `postId` - The ID of the post to get. - pub fn get(&self, user_id: &str, blog_id: &str, post_id: &str) -> PostUserInfoGetCall<'a, C, NC, A> { + pub fn get(&self, user_id: &str, blog_id: &str, post_id: &str) -> PostUserInfoGetCall<'a, C, A> { PostUserInfoGetCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1965,7 +1961,7 @@ impl<'a, C, NC, A> PostUserInfoMethods<'a, C, NC, A> { /// /// * `userId` - ID of the user for the per-user information to be fetched. Either the word 'self' (sans quote marks) or the user's profile identifier. /// * `blogId` - ID of the blog to fetch posts from. - pub fn list(&self, user_id: &str, blog_id: &str) -> PostUserInfoListCall<'a, C, NC, A> { + pub fn list(&self, user_id: &str, blog_id: &str) -> PostUserInfoListCall<'a, C, A> { PostUserInfoListCall { hub: self.hub, _user_id: user_id.to_string(), @@ -2016,15 +2012,15 @@ impl<'a, C, NC, A> PostUserInfoMethods<'a, C, NC, A> { /// let rb = hub.blog_user_infos(); /// # } /// ``` -pub struct BlogUserInfoMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BlogUserInfoMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, } -impl<'a, C, NC, A> MethodsBuilder for BlogUserInfoMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for BlogUserInfoMethods<'a, C, A> {} -impl<'a, C, NC, A> BlogUserInfoMethods<'a, C, NC, A> { +impl<'a, C, A> BlogUserInfoMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2034,7 +2030,7 @@ impl<'a, C, NC, A> BlogUserInfoMethods<'a, C, NC, A> { /// /// * `userId` - ID of the user whose blogs are to be fetched. Either the word 'self' (sans quote marks) or the user's profile identifier. /// * `blogId` - The ID of the blog to get. - pub fn get(&self, user_id: &str, blog_id: &str) -> BlogUserInfoGetCall<'a, C, NC, A> { + pub fn get(&self, user_id: &str, blog_id: &str) -> BlogUserInfoGetCall<'a, C, A> { BlogUserInfoGetCall { hub: self.hub, _user_id: user_id.to_string(), @@ -2077,15 +2073,15 @@ impl<'a, C, NC, A> BlogUserInfoMethods<'a, C, NC, A> { /// let rb = hub.pages(); /// # } /// ``` -pub struct PageMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PageMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, } -impl<'a, C, NC, A> MethodsBuilder for PageMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PageMethods<'a, C, A> {} -impl<'a, C, NC, A> PageMethods<'a, C, NC, A> { +impl<'a, C, A> PageMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2095,7 +2091,7 @@ impl<'a, C, NC, A> PageMethods<'a, C, NC, A> { /// /// * `blogId` - ID of the blog containing the page. /// * `pageId` - The ID of the page to get. - pub fn get(&self, blog_id: &str, page_id: &str) -> PageGetCall<'a, C, NC, A> { + pub fn get(&self, blog_id: &str, page_id: &str) -> PageGetCall<'a, C, A> { PageGetCall { hub: self.hub, _blog_id: blog_id.to_string(), @@ -2114,7 +2110,7 @@ impl<'a, C, NC, A> PageMethods<'a, C, NC, A> { /// # Arguments /// /// * `blogId` - ID of the blog to fetch Pages from. - pub fn list(&self, blog_id: &str) -> PageListCall<'a, C, NC, A> { + pub fn list(&self, blog_id: &str) -> PageListCall<'a, C, A> { PageListCall { hub: self.hub, _blog_id: blog_id.to_string(), @@ -2137,7 +2133,7 @@ impl<'a, C, NC, A> PageMethods<'a, C, NC, A> { /// /// * `blogId` - The ID of the blog. /// * `pageId` - The ID of the page. - pub fn revert(&self, blog_id: &str, page_id: &str) -> PageRevertCall<'a, C, NC, A> { + pub fn revert(&self, blog_id: &str, page_id: &str) -> PageRevertCall<'a, C, A> { PageRevertCall { hub: self.hub, _blog_id: blog_id.to_string(), @@ -2156,7 +2152,7 @@ impl<'a, C, NC, A> PageMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `blogId` - ID of the blog to add the page to. - pub fn insert(&self, request: &Page, blog_id: &str) -> PageInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Page, blog_id: &str) -> PageInsertCall<'a, C, A> { PageInsertCall { hub: self.hub, _request: request.clone(), @@ -2177,7 +2173,7 @@ impl<'a, C, NC, A> PageMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `blogId` - The ID of the Blog. /// * `pageId` - The ID of the Page. - pub fn patch(&self, request: &Page, blog_id: &str, page_id: &str) -> PagePatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Page, blog_id: &str, page_id: &str) -> PagePatchCall<'a, C, A> { PagePatchCall { hub: self.hub, _request: request.clone(), @@ -2199,7 +2195,7 @@ impl<'a, C, NC, A> PageMethods<'a, C, NC, A> { /// /// * `blogId` - The ID of the blog. /// * `pageId` - The ID of the page. - pub fn publish(&self, blog_id: &str, page_id: &str) -> PagePublishCall<'a, C, NC, A> { + pub fn publish(&self, blog_id: &str, page_id: &str) -> PagePublishCall<'a, C, A> { PagePublishCall { hub: self.hub, _blog_id: blog_id.to_string(), @@ -2219,7 +2215,7 @@ impl<'a, C, NC, A> PageMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `blogId` - The ID of the Blog. /// * `pageId` - The ID of the Page. - pub fn update(&self, request: &Page, blog_id: &str, page_id: &str) -> PageUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Page, blog_id: &str, page_id: &str) -> PageUpdateCall<'a, C, A> { PageUpdateCall { hub: self.hub, _request: request.clone(), @@ -2241,7 +2237,7 @@ impl<'a, C, NC, A> PageMethods<'a, C, NC, A> { /// /// * `blogId` - The ID of the Blog. /// * `pageId` - The ID of the Page. - pub fn delete(&self, blog_id: &str, page_id: &str) -> PageDeleteCall<'a, C, NC, A> { + pub fn delete(&self, blog_id: &str, page_id: &str) -> PageDeleteCall<'a, C, A> { PageDeleteCall { hub: self.hub, _blog_id: blog_id.to_string(), @@ -2292,10 +2288,10 @@ impl<'a, C, NC, A> PageMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct PageViewGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PageViewGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _blog_id: String, _range: Vec, _delegate: Option<&'a mut Delegate>, @@ -2303,9 +2299,9 @@ pub struct PageViewGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PageViewGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PageViewGetCall<'a, C, A> {} -impl<'a, C, NC, A> PageViewGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PageViewGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2444,7 +2440,7 @@ impl<'a, C, NC, A> PageViewGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the blog to get. - pub fn blog_id(mut self, new_value: &str) -> PageViewGetCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> PageViewGetCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -2452,7 +2448,7 @@ impl<'a, C, NC, A> PageViewGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Each appended value will retain its original ordering and be '/'-separated in the URL's parameters. /// /// - pub fn add_range(mut self, new_value: &str) -> PageViewGetCall<'a, C, NC, A> { + pub fn add_range(mut self, new_value: &str) -> PageViewGetCall<'a, C, A> { self._range.push(new_value.to_string()); self } @@ -2463,7 +2459,7 @@ impl<'a, C, NC, A> PageViewGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PageViewGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PageViewGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2484,7 +2480,7 @@ impl<'a, C, NC, A> PageViewGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PageViewGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PageViewGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2501,7 +2497,7 @@ impl<'a, C, NC, A> PageViewGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PageViewGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PageViewGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2539,19 +2535,19 @@ impl<'a, C, NC, A> PageViewGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct UserGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _user_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserGetCall<'a, C, A> {} -impl<'a, C, NC, A> UserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2683,7 +2679,7 @@ impl<'a, C, NC, A> UserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// The ID of the user to get. - pub fn user_id(mut self, new_value: &str) -> UserGetCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserGetCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -2694,7 +2690,7 @@ impl<'a, C, NC, A> UserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2715,7 +2711,7 @@ impl<'a, C, NC, A> UserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2732,7 +2728,7 @@ impl<'a, C, NC, A> UserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2774,10 +2770,10 @@ impl<'a, C, NC, A> UserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct BlogListByUserCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BlogListByUserCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _user_id: String, _view: Option, _status: Vec, @@ -2788,9 +2784,9 @@ pub struct BlogListByUserCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BlogListByUserCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BlogListByUserCall<'a, C, A> {} -impl<'a, C, NC, A> BlogListByUserCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BlogListByUserCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2942,7 +2938,7 @@ impl<'a, C, NC, A> BlogListByUserCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// ID of the user whose blogs are to be fetched. Either the word 'self' (sans quote marks) or the user's profile identifier. - pub fn user_id(mut self, new_value: &str) -> BlogListByUserCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> BlogListByUserCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -2950,7 +2946,7 @@ impl<'a, C, NC, A> BlogListByUserCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Access level with which to view the blogs. Note that some fields require elevated access. - pub fn view(mut self, new_value: &str) -> BlogListByUserCall<'a, C, NC, A> { + pub fn view(mut self, new_value: &str) -> BlogListByUserCall<'a, C, A> { self._view = Some(new_value.to_string()); self } @@ -2959,7 +2955,7 @@ impl<'a, C, NC, A> BlogListByUserCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Blog statuses to include in the result (default: Live blogs only). Note that ADMIN access is required to view deleted blogs. - pub fn add_status(mut self, new_value: &str) -> BlogListByUserCall<'a, C, NC, A> { + pub fn add_status(mut self, new_value: &str) -> BlogListByUserCall<'a, C, A> { self._status.push(new_value.to_string()); self } @@ -2968,7 +2964,7 @@ impl<'a, C, NC, A> BlogListByUserCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// User access types for blogs to include in the results, e.g. AUTHOR will return blogs where the user has author level access. If no roles are specified, defaults to ADMIN and AUTHOR roles. - pub fn add_role(mut self, new_value: &str) -> BlogListByUserCall<'a, C, NC, A> { + pub fn add_role(mut self, new_value: &str) -> BlogListByUserCall<'a, C, A> { self._role.push(new_value.to_string()); self } @@ -2976,7 +2972,7 @@ impl<'a, C, NC, A> BlogListByUserCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Whether the response is a list of blogs with per-user information instead of just blogs. - pub fn fetch_user_info(mut self, new_value: bool) -> BlogListByUserCall<'a, C, NC, A> { + pub fn fetch_user_info(mut self, new_value: bool) -> BlogListByUserCall<'a, C, A> { self._fetch_user_info = Some(new_value); self } @@ -2987,7 +2983,7 @@ impl<'a, C, NC, A> BlogListByUserCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BlogListByUserCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BlogListByUserCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3008,7 +3004,7 @@ impl<'a, C, NC, A> BlogListByUserCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BlogListByUserCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BlogListByUserCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3025,7 +3021,7 @@ impl<'a, C, NC, A> BlogListByUserCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BlogListByUserCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BlogListByUserCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3065,10 +3061,10 @@ impl<'a, C, NC, A> BlogListByUserCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct BlogGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BlogGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _blog_id: String, _view: Option, _max_posts: Option, @@ -3077,9 +3073,9 @@ pub struct BlogGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BlogGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BlogGetCall<'a, C, A> {} -impl<'a, C, NC, A> BlogGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BlogGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3217,7 +3213,7 @@ impl<'a, C, NC, A> BlogGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// The ID of the blog to get. - pub fn blog_id(mut self, new_value: &str) -> BlogGetCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> BlogGetCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -3225,7 +3221,7 @@ impl<'a, C, NC, A> BlogGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Access level with which to view the blog. Note that some fields require elevated access. - pub fn view(mut self, new_value: &str) -> BlogGetCall<'a, C, NC, A> { + pub fn view(mut self, new_value: &str) -> BlogGetCall<'a, C, A> { self._view = Some(new_value.to_string()); self } @@ -3233,7 +3229,7 @@ impl<'a, C, NC, A> BlogGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Maximum number of posts to pull back with the blog. - pub fn max_posts(mut self, new_value: u32) -> BlogGetCall<'a, C, NC, A> { + pub fn max_posts(mut self, new_value: u32) -> BlogGetCall<'a, C, A> { self._max_posts = Some(new_value); self } @@ -3244,7 +3240,7 @@ impl<'a, C, NC, A> BlogGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BlogGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BlogGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3265,7 +3261,7 @@ impl<'a, C, NC, A> BlogGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BlogGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BlogGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3282,7 +3278,7 @@ impl<'a, C, NC, A> BlogGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BlogGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BlogGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3321,10 +3317,10 @@ impl<'a, C, NC, A> BlogGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct BlogGetByUrlCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BlogGetByUrlCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _url: String, _view: Option, _delegate: Option<&'a mut Delegate>, @@ -3332,9 +3328,9 @@ pub struct BlogGetByUrlCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BlogGetByUrlCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BlogGetByUrlCall<'a, C, A> {} -impl<'a, C, NC, A> BlogGetByUrlCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BlogGetByUrlCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3445,7 +3441,7 @@ impl<'a, C, NC, A> BlogGetByUrlCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The URL of the blog to retrieve. - pub fn url(mut self, new_value: &str) -> BlogGetByUrlCall<'a, C, NC, A> { + pub fn url(mut self, new_value: &str) -> BlogGetByUrlCall<'a, C, A> { self._url = new_value.to_string(); self } @@ -3453,7 +3449,7 @@ impl<'a, C, NC, A> BlogGetByUrlCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Access level with which to view the blog. Note that some fields require elevated access. - pub fn view(mut self, new_value: &str) -> BlogGetByUrlCall<'a, C, NC, A> { + pub fn view(mut self, new_value: &str) -> BlogGetByUrlCall<'a, C, A> { self._view = Some(new_value.to_string()); self } @@ -3464,7 +3460,7 @@ impl<'a, C, NC, A> BlogGetByUrlCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BlogGetByUrlCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BlogGetByUrlCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3485,7 +3481,7 @@ impl<'a, C, NC, A> BlogGetByUrlCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BlogGetByUrlCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BlogGetByUrlCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3502,7 +3498,7 @@ impl<'a, C, NC, A> BlogGetByUrlCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BlogGetByUrlCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BlogGetByUrlCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3551,10 +3547,10 @@ impl<'a, C, NC, A> BlogGetByUrlCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct PostUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PostUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _request: Post, _blog_id: String, _post_id: String, @@ -3568,9 +3564,9 @@ pub struct PostUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PostUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PostUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> PostUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PostUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3725,7 +3721,7 @@ impl<'a, C, NC, A> PostUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Post) -> PostUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Post) -> PostUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3735,7 +3731,7 @@ impl<'a, C, NC, A> PostUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the Blog. - pub fn blog_id(mut self, new_value: &str) -> PostUpdateCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> PostUpdateCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -3745,7 +3741,7 @@ impl<'a, C, NC, A> PostUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the Post. - pub fn post_id(mut self, new_value: &str) -> PostUpdateCall<'a, C, NC, A> { + pub fn post_id(mut self, new_value: &str) -> PostUpdateCall<'a, C, A> { self._post_id = new_value.to_string(); self } @@ -3753,7 +3749,7 @@ impl<'a, C, NC, A> PostUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether a revert action should be performed when the post is updated (default: false). - pub fn revert(mut self, new_value: bool) -> PostUpdateCall<'a, C, NC, A> { + pub fn revert(mut self, new_value: bool) -> PostUpdateCall<'a, C, A> { self._revert = Some(new_value); self } @@ -3761,7 +3757,7 @@ impl<'a, C, NC, A> PostUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether a publish action should be performed when the post is updated (default: false). - pub fn publish(mut self, new_value: bool) -> PostUpdateCall<'a, C, NC, A> { + pub fn publish(mut self, new_value: bool) -> PostUpdateCall<'a, C, A> { self._publish = Some(new_value); self } @@ -3769,7 +3765,7 @@ impl<'a, C, NC, A> PostUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Maximum number of comments to retrieve with the returned post. - pub fn max_comments(mut self, new_value: u32) -> PostUpdateCall<'a, C, NC, A> { + pub fn max_comments(mut self, new_value: u32) -> PostUpdateCall<'a, C, A> { self._max_comments = Some(new_value); self } @@ -3777,7 +3773,7 @@ impl<'a, C, NC, A> PostUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether image URL metadata for each post is included in the returned result (default: false). - pub fn fetch_images(mut self, new_value: bool) -> PostUpdateCall<'a, C, NC, A> { + pub fn fetch_images(mut self, new_value: bool) -> PostUpdateCall<'a, C, A> { self._fetch_images = Some(new_value); self } @@ -3785,7 +3781,7 @@ impl<'a, C, NC, A> PostUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether the body content of the post is included with the result (default: true). - pub fn fetch_body(mut self, new_value: bool) -> PostUpdateCall<'a, C, NC, A> { + pub fn fetch_body(mut self, new_value: bool) -> PostUpdateCall<'a, C, A> { self._fetch_body = Some(new_value); self } @@ -3796,7 +3792,7 @@ impl<'a, C, NC, A> PostUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3817,7 +3813,7 @@ impl<'a, C, NC, A> PostUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PostUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PostUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3834,7 +3830,7 @@ impl<'a, C, NC, A> PostUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PostUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PostUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3874,10 +3870,10 @@ impl<'a, C, NC, A> PostUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct PostGetByPathCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PostGetByPathCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _blog_id: String, _path: String, _view: Option, @@ -3887,9 +3883,9 @@ pub struct PostGetByPathCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PostGetByPathCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PostGetByPathCall<'a, C, A> {} -impl<'a, C, NC, A> PostGetByPathCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PostGetByPathCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4028,7 +4024,7 @@ impl<'a, C, NC, A> PostGetByPathCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// ID of the blog to fetch the post from. - pub fn blog_id(mut self, new_value: &str) -> PostGetByPathCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> PostGetByPathCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -4038,7 +4034,7 @@ impl<'a, C, NC, A> PostGetByPathCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Path of the Post to retrieve. - pub fn path(mut self, new_value: &str) -> PostGetByPathCall<'a, C, NC, A> { + pub fn path(mut self, new_value: &str) -> PostGetByPathCall<'a, C, A> { self._path = new_value.to_string(); self } @@ -4046,7 +4042,7 @@ impl<'a, C, NC, A> PostGetByPathCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Access level with which to view the returned result. Note that some fields require elevated access. - pub fn view(mut self, new_value: &str) -> PostGetByPathCall<'a, C, NC, A> { + pub fn view(mut self, new_value: &str) -> PostGetByPathCall<'a, C, A> { self._view = Some(new_value.to_string()); self } @@ -4054,7 +4050,7 @@ impl<'a, C, NC, A> PostGetByPathCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Maximum number of comments to pull back on a post. - pub fn max_comments(mut self, new_value: u32) -> PostGetByPathCall<'a, C, NC, A> { + pub fn max_comments(mut self, new_value: u32) -> PostGetByPathCall<'a, C, A> { self._max_comments = Some(new_value); self } @@ -4065,7 +4061,7 @@ impl<'a, C, NC, A> PostGetByPathCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostGetByPathCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostGetByPathCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4086,7 +4082,7 @@ impl<'a, C, NC, A> PostGetByPathCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PostGetByPathCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PostGetByPathCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4103,7 +4099,7 @@ impl<'a, C, NC, A> PostGetByPathCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PostGetByPathCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PostGetByPathCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4145,10 +4141,10 @@ impl<'a, C, NC, A> PostGetByPathCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct PostGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PostGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _blog_id: String, _post_id: String, _view: Option, @@ -4160,9 +4156,9 @@ pub struct PostGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PostGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PostGetCall<'a, C, A> {} -impl<'a, C, NC, A> PostGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PostGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4307,7 +4303,7 @@ impl<'a, C, NC, A> PostGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// ID of the blog to fetch the post from. - pub fn blog_id(mut self, new_value: &str) -> PostGetCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> PostGetCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -4317,7 +4313,7 @@ impl<'a, C, NC, A> PostGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// The ID of the post - pub fn post_id(mut self, new_value: &str) -> PostGetCall<'a, C, NC, A> { + pub fn post_id(mut self, new_value: &str) -> PostGetCall<'a, C, A> { self._post_id = new_value.to_string(); self } @@ -4325,7 +4321,7 @@ impl<'a, C, NC, A> PostGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Access level with which to view the returned result. Note that some fields require elevated access. - pub fn view(mut self, new_value: &str) -> PostGetCall<'a, C, NC, A> { + pub fn view(mut self, new_value: &str) -> PostGetCall<'a, C, A> { self._view = Some(new_value.to_string()); self } @@ -4333,7 +4329,7 @@ impl<'a, C, NC, A> PostGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Maximum number of comments to pull back on a post. - pub fn max_comments(mut self, new_value: u32) -> PostGetCall<'a, C, NC, A> { + pub fn max_comments(mut self, new_value: u32) -> PostGetCall<'a, C, A> { self._max_comments = Some(new_value); self } @@ -4341,7 +4337,7 @@ impl<'a, C, NC, A> PostGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Whether image URL metadata for each post is included (default: false). - pub fn fetch_images(mut self, new_value: bool) -> PostGetCall<'a, C, NC, A> { + pub fn fetch_images(mut self, new_value: bool) -> PostGetCall<'a, C, A> { self._fetch_images = Some(new_value); self } @@ -4349,7 +4345,7 @@ impl<'a, C, NC, A> PostGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Whether the body content of the post is included (default: true). This should be set to false when the post bodies are not required, to help minimize traffic. - pub fn fetch_body(mut self, new_value: bool) -> PostGetCall<'a, C, NC, A> { + pub fn fetch_body(mut self, new_value: bool) -> PostGetCall<'a, C, A> { self._fetch_body = Some(new_value); self } @@ -4360,7 +4356,7 @@ impl<'a, C, NC, A> PostGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4381,7 +4377,7 @@ impl<'a, C, NC, A> PostGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PostGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PostGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4398,7 +4394,7 @@ impl<'a, C, NC, A> PostGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PostGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PostGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4445,10 +4441,10 @@ impl<'a, C, NC, A> PostGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct PostInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PostInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _request: Post, _blog_id: String, _is_draft: Option, @@ -4459,9 +4455,9 @@ pub struct PostInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PostInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PostInsertCall<'a, C, A> {} -impl<'a, C, NC, A> PostInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PostInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4609,7 +4605,7 @@ impl<'a, C, NC, A> PostInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Post) -> PostInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Post) -> PostInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4619,7 +4615,7 @@ impl<'a, C, NC, A> PostInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// ID of the blog to add the post to. - pub fn blog_id(mut self, new_value: &str) -> PostInsertCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> PostInsertCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -4627,7 +4623,7 @@ impl<'a, C, NC, A> PostInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether to create the post as a draft (default: false). - pub fn is_draft(mut self, new_value: bool) -> PostInsertCall<'a, C, NC, A> { + pub fn is_draft(mut self, new_value: bool) -> PostInsertCall<'a, C, A> { self._is_draft = Some(new_value); self } @@ -4635,7 +4631,7 @@ impl<'a, C, NC, A> PostInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether image URL metadata for each post is included in the returned result (default: false). - pub fn fetch_images(mut self, new_value: bool) -> PostInsertCall<'a, C, NC, A> { + pub fn fetch_images(mut self, new_value: bool) -> PostInsertCall<'a, C, A> { self._fetch_images = Some(new_value); self } @@ -4643,7 +4639,7 @@ impl<'a, C, NC, A> PostInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether the body content of the post is included with the result (default: true). - pub fn fetch_body(mut self, new_value: bool) -> PostInsertCall<'a, C, NC, A> { + pub fn fetch_body(mut self, new_value: bool) -> PostInsertCall<'a, C, A> { self._fetch_body = Some(new_value); self } @@ -4654,7 +4650,7 @@ impl<'a, C, NC, A> PostInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4675,7 +4671,7 @@ impl<'a, C, NC, A> PostInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PostInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PostInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4692,7 +4688,7 @@ impl<'a, C, NC, A> PostInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PostInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PostInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4731,10 +4727,10 @@ impl<'a, C, NC, A> PostInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct PostPublishCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PostPublishCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _blog_id: String, _post_id: String, _publish_date: Option, @@ -4743,9 +4739,9 @@ pub struct PostPublishCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PostPublishCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PostPublishCall<'a, C, A> {} -impl<'a, C, NC, A> PostPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PostPublishCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4881,7 +4877,7 @@ impl<'a, C, NC, A> PostPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the Blog. - pub fn blog_id(mut self, new_value: &str) -> PostPublishCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> PostPublishCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -4891,7 +4887,7 @@ impl<'a, C, NC, A> PostPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the Post. - pub fn post_id(mut self, new_value: &str) -> PostPublishCall<'a, C, NC, A> { + pub fn post_id(mut self, new_value: &str) -> PostPublishCall<'a, C, A> { self._post_id = new_value.to_string(); self } @@ -4899,7 +4895,7 @@ impl<'a, C, NC, A> PostPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Optional date and time to schedule the publishing of the Blog. If no publishDate parameter is given, the post is either published at the a previously saved schedule date (if present), or the current time. If a future date is given, the post will be scheduled to be published. - pub fn publish_date(mut self, new_value: &str) -> PostPublishCall<'a, C, NC, A> { + pub fn publish_date(mut self, new_value: &str) -> PostPublishCall<'a, C, A> { self._publish_date = Some(new_value.to_string()); self } @@ -4910,7 +4906,7 @@ impl<'a, C, NC, A> PostPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostPublishCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostPublishCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4931,7 +4927,7 @@ impl<'a, C, NC, A> PostPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PostPublishCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PostPublishCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4948,7 +4944,7 @@ impl<'a, C, NC, A> PostPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PostPublishCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PostPublishCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4986,10 +4982,10 @@ impl<'a, C, NC, A> PostPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct PostDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PostDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _blog_id: String, _post_id: String, _delegate: Option<&'a mut Delegate>, @@ -4997,9 +4993,9 @@ pub struct PostDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PostDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PostDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> PostDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PostDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5121,7 +5117,7 @@ impl<'a, C, NC, A> PostDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the Blog. - pub fn blog_id(mut self, new_value: &str) -> PostDeleteCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> PostDeleteCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -5131,7 +5127,7 @@ impl<'a, C, NC, A> PostDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the Post. - pub fn post_id(mut self, new_value: &str) -> PostDeleteCall<'a, C, NC, A> { + pub fn post_id(mut self, new_value: &str) -> PostDeleteCall<'a, C, A> { self._post_id = new_value.to_string(); self } @@ -5142,7 +5138,7 @@ impl<'a, C, NC, A> PostDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5163,7 +5159,7 @@ impl<'a, C, NC, A> PostDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PostDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PostDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5180,7 +5176,7 @@ impl<'a, C, NC, A> PostDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PostDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PostDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5218,10 +5214,10 @@ impl<'a, C, NC, A> PostDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct PostRevertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PostRevertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _blog_id: String, _post_id: String, _delegate: Option<&'a mut Delegate>, @@ -5229,9 +5225,9 @@ pub struct PostRevertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PostRevertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PostRevertCall<'a, C, A> {} -impl<'a, C, NC, A> PostRevertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PostRevertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5364,7 +5360,7 @@ impl<'a, C, NC, A> PostRevertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the Blog. - pub fn blog_id(mut self, new_value: &str) -> PostRevertCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> PostRevertCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -5374,7 +5370,7 @@ impl<'a, C, NC, A> PostRevertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the Post. - pub fn post_id(mut self, new_value: &str) -> PostRevertCall<'a, C, NC, A> { + pub fn post_id(mut self, new_value: &str) -> PostRevertCall<'a, C, A> { self._post_id = new_value.to_string(); self } @@ -5385,7 +5381,7 @@ impl<'a, C, NC, A> PostRevertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostRevertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostRevertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5406,7 +5402,7 @@ impl<'a, C, NC, A> PostRevertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PostRevertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PostRevertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5423,7 +5419,7 @@ impl<'a, C, NC, A> PostRevertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PostRevertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PostRevertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5463,10 +5459,10 @@ impl<'a, C, NC, A> PostRevertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct PostSearchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PostSearchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _blog_id: String, _q: String, _order_by: Option, @@ -5476,9 +5472,9 @@ pub struct PostSearchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PostSearchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PostSearchCall<'a, C, A> {} -impl<'a, C, NC, A> PostSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PostSearchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5617,7 +5613,7 @@ impl<'a, C, NC, A> PostSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// ID of the blog to fetch the post from. - pub fn blog_id(mut self, new_value: &str) -> PostSearchCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> PostSearchCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -5627,7 +5623,7 @@ impl<'a, C, NC, A> PostSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Query terms to search this blog for matching posts. - pub fn q(mut self, new_value: &str) -> PostSearchCall<'a, C, NC, A> { + pub fn q(mut self, new_value: &str) -> PostSearchCall<'a, C, A> { self._q = new_value.to_string(); self } @@ -5635,7 +5631,7 @@ impl<'a, C, NC, A> PostSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Sort search results - pub fn order_by(mut self, new_value: &str) -> PostSearchCall<'a, C, NC, A> { + pub fn order_by(mut self, new_value: &str) -> PostSearchCall<'a, C, A> { self._order_by = Some(new_value.to_string()); self } @@ -5643,7 +5639,7 @@ impl<'a, C, NC, A> PostSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether the body content of posts is included (default: true). This should be set to false when the post bodies are not required, to help minimize traffic. - pub fn fetch_bodies(mut self, new_value: bool) -> PostSearchCall<'a, C, NC, A> { + pub fn fetch_bodies(mut self, new_value: bool) -> PostSearchCall<'a, C, A> { self._fetch_bodies = Some(new_value); self } @@ -5654,7 +5650,7 @@ impl<'a, C, NC, A> PostSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostSearchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostSearchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5675,7 +5671,7 @@ impl<'a, C, NC, A> PostSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PostSearchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PostSearchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5692,7 +5688,7 @@ impl<'a, C, NC, A> PostSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PostSearchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PostSearchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5741,10 +5737,10 @@ impl<'a, C, NC, A> PostSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct PostPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PostPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _request: Post, _blog_id: String, _post_id: String, @@ -5758,9 +5754,9 @@ pub struct PostPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PostPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PostPatchCall<'a, C, A> {} -impl<'a, C, NC, A> PostPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PostPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5915,7 +5911,7 @@ impl<'a, C, NC, A> PostPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Post) -> PostPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Post) -> PostPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5925,7 +5921,7 @@ impl<'a, C, NC, A> PostPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the Blog. - pub fn blog_id(mut self, new_value: &str) -> PostPatchCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> PostPatchCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -5935,7 +5931,7 @@ impl<'a, C, NC, A> PostPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the Post. - pub fn post_id(mut self, new_value: &str) -> PostPatchCall<'a, C, NC, A> { + pub fn post_id(mut self, new_value: &str) -> PostPatchCall<'a, C, A> { self._post_id = new_value.to_string(); self } @@ -5943,7 +5939,7 @@ impl<'a, C, NC, A> PostPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether a revert action should be performed when the post is updated (default: false). - pub fn revert(mut self, new_value: bool) -> PostPatchCall<'a, C, NC, A> { + pub fn revert(mut self, new_value: bool) -> PostPatchCall<'a, C, A> { self._revert = Some(new_value); self } @@ -5951,7 +5947,7 @@ impl<'a, C, NC, A> PostPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether a publish action should be performed when the post is updated (default: false). - pub fn publish(mut self, new_value: bool) -> PostPatchCall<'a, C, NC, A> { + pub fn publish(mut self, new_value: bool) -> PostPatchCall<'a, C, A> { self._publish = Some(new_value); self } @@ -5959,7 +5955,7 @@ impl<'a, C, NC, A> PostPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Maximum number of comments to retrieve with the returned post. - pub fn max_comments(mut self, new_value: u32) -> PostPatchCall<'a, C, NC, A> { + pub fn max_comments(mut self, new_value: u32) -> PostPatchCall<'a, C, A> { self._max_comments = Some(new_value); self } @@ -5967,7 +5963,7 @@ impl<'a, C, NC, A> PostPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether image URL metadata for each post is included in the returned result (default: false). - pub fn fetch_images(mut self, new_value: bool) -> PostPatchCall<'a, C, NC, A> { + pub fn fetch_images(mut self, new_value: bool) -> PostPatchCall<'a, C, A> { self._fetch_images = Some(new_value); self } @@ -5975,7 +5971,7 @@ impl<'a, C, NC, A> PostPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether the body content of the post is included with the result (default: true). - pub fn fetch_body(mut self, new_value: bool) -> PostPatchCall<'a, C, NC, A> { + pub fn fetch_body(mut self, new_value: bool) -> PostPatchCall<'a, C, A> { self._fetch_body = Some(new_value); self } @@ -5986,7 +5982,7 @@ impl<'a, C, NC, A> PostPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6007,7 +6003,7 @@ impl<'a, C, NC, A> PostPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PostPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PostPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6024,7 +6020,7 @@ impl<'a, C, NC, A> PostPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PostPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PostPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6072,10 +6068,10 @@ impl<'a, C, NC, A> PostPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct PostListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PostListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _blog_id: String, _view: Option, _status: Vec, @@ -6092,9 +6088,9 @@ pub struct PostListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PostListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PostListCall<'a, C, A> {} -impl<'a, C, NC, A> PostListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PostListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6260,7 +6256,7 @@ impl<'a, C, NC, A> PostListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// ID of the blog to fetch posts from. - pub fn blog_id(mut self, new_value: &str) -> PostListCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> PostListCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -6268,7 +6264,7 @@ impl<'a, C, NC, A> PostListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Access level with which to view the returned result. Note that some fields require escalated access. - pub fn view(mut self, new_value: &str) -> PostListCall<'a, C, NC, A> { + pub fn view(mut self, new_value: &str) -> PostListCall<'a, C, A> { self._view = Some(new_value.to_string()); self } @@ -6277,7 +6273,7 @@ impl<'a, C, NC, A> PostListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Statuses to include in the results. - pub fn add_status(mut self, new_value: &str) -> PostListCall<'a, C, NC, A> { + pub fn add_status(mut self, new_value: &str) -> PostListCall<'a, C, A> { self._status.push(new_value.to_string()); self } @@ -6285,7 +6281,7 @@ impl<'a, C, NC, A> PostListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Earliest post date to fetch, a date-time with RFC 3339 formatting. - pub fn start_date(mut self, new_value: &str) -> PostListCall<'a, C, NC, A> { + pub fn start_date(mut self, new_value: &str) -> PostListCall<'a, C, A> { self._start_date = Some(new_value.to_string()); self } @@ -6293,7 +6289,7 @@ impl<'a, C, NC, A> PostListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Continuation token if the request is paged. - pub fn page_token(mut self, new_value: &str) -> PostListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> PostListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -6301,7 +6297,7 @@ impl<'a, C, NC, A> PostListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Sort search results - pub fn order_by(mut self, new_value: &str) -> PostListCall<'a, C, NC, A> { + pub fn order_by(mut self, new_value: &str) -> PostListCall<'a, C, A> { self._order_by = Some(new_value.to_string()); self } @@ -6309,7 +6305,7 @@ impl<'a, C, NC, A> PostListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Maximum number of posts to fetch. - pub fn max_results(mut self, new_value: u32) -> PostListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> PostListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -6317,7 +6313,7 @@ impl<'a, C, NC, A> PostListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Comma-separated list of labels to search for. - pub fn labels(mut self, new_value: &str) -> PostListCall<'a, C, NC, A> { + pub fn labels(mut self, new_value: &str) -> PostListCall<'a, C, A> { self._labels = Some(new_value.to_string()); self } @@ -6325,7 +6321,7 @@ impl<'a, C, NC, A> PostListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Whether image URL metadata for each post is included. - pub fn fetch_images(mut self, new_value: bool) -> PostListCall<'a, C, NC, A> { + pub fn fetch_images(mut self, new_value: bool) -> PostListCall<'a, C, A> { self._fetch_images = Some(new_value); self } @@ -6333,7 +6329,7 @@ impl<'a, C, NC, A> PostListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Whether the body content of posts is included (default: true). This should be set to false when the post bodies are not required, to help minimize traffic. - pub fn fetch_bodies(mut self, new_value: bool) -> PostListCall<'a, C, NC, A> { + pub fn fetch_bodies(mut self, new_value: bool) -> PostListCall<'a, C, A> { self._fetch_bodies = Some(new_value); self } @@ -6341,7 +6337,7 @@ impl<'a, C, NC, A> PostListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Latest post date to fetch, a date-time with RFC 3339 formatting. - pub fn end_date(mut self, new_value: &str) -> PostListCall<'a, C, NC, A> { + pub fn end_date(mut self, new_value: &str) -> PostListCall<'a, C, A> { self._end_date = Some(new_value.to_string()); self } @@ -6352,7 +6348,7 @@ impl<'a, C, NC, A> PostListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6373,7 +6369,7 @@ impl<'a, C, NC, A> PostListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PostListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PostListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6390,7 +6386,7 @@ impl<'a, C, NC, A> PostListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PostListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PostListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6429,10 +6425,10 @@ impl<'a, C, NC, A> PostListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct CommentGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CommentGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _blog_id: String, _post_id: String, _comment_id: String, @@ -6442,9 +6438,9 @@ pub struct CommentGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CommentGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CommentGetCall<'a, C, A> {} -impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CommentGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6581,7 +6577,7 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// ID of the blog to containing the comment. - pub fn blog_id(mut self, new_value: &str) -> CommentGetCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> CommentGetCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -6591,7 +6587,7 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// ID of the post to fetch posts from. - pub fn post_id(mut self, new_value: &str) -> CommentGetCall<'a, C, NC, A> { + pub fn post_id(mut self, new_value: &str) -> CommentGetCall<'a, C, A> { self._post_id = new_value.to_string(); self } @@ -6601,7 +6597,7 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the comment to get. - pub fn comment_id(mut self, new_value: &str) -> CommentGetCall<'a, C, NC, A> { + pub fn comment_id(mut self, new_value: &str) -> CommentGetCall<'a, C, A> { self._comment_id = new_value.to_string(); self } @@ -6609,7 +6605,7 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Access level for the requested comment (default: READER). Note that some comments will require elevated permissions, for example comments where the parent posts which is in a draft state, or comments that are pending moderation. - pub fn view(mut self, new_value: &str) -> CommentGetCall<'a, C, NC, A> { + pub fn view(mut self, new_value: &str) -> CommentGetCall<'a, C, A> { self._view = Some(new_value.to_string()); self } @@ -6620,7 +6616,7 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6641,7 +6637,7 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CommentGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CommentGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6658,7 +6654,7 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CommentGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CommentGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6696,10 +6692,10 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct CommentRemoveContentCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CommentRemoveContentCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _blog_id: String, _post_id: String, _comment_id: String, @@ -6708,9 +6704,9 @@ pub struct CommentRemoveContentCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CommentRemoveContentCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CommentRemoveContentCall<'a, C, A> {} -impl<'a, C, NC, A> CommentRemoveContentCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CommentRemoveContentCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6844,7 +6840,7 @@ impl<'a, C, NC, A> CommentRemoveContentCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The ID of the Blog. - pub fn blog_id(mut self, new_value: &str) -> CommentRemoveContentCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> CommentRemoveContentCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -6854,7 +6850,7 @@ impl<'a, C, NC, A> CommentRemoveContentCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The ID of the Post. - pub fn post_id(mut self, new_value: &str) -> CommentRemoveContentCall<'a, C, NC, A> { + pub fn post_id(mut self, new_value: &str) -> CommentRemoveContentCall<'a, C, A> { self._post_id = new_value.to_string(); self } @@ -6864,7 +6860,7 @@ impl<'a, C, NC, A> CommentRemoveContentCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The ID of the comment to delete content from. - pub fn comment_id(mut self, new_value: &str) -> CommentRemoveContentCall<'a, C, NC, A> { + pub fn comment_id(mut self, new_value: &str) -> CommentRemoveContentCall<'a, C, A> { self._comment_id = new_value.to_string(); self } @@ -6875,7 +6871,7 @@ impl<'a, C, NC, A> CommentRemoveContentCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentRemoveContentCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentRemoveContentCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6896,7 +6892,7 @@ impl<'a, C, NC, A> CommentRemoveContentCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CommentRemoveContentCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CommentRemoveContentCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6913,7 +6909,7 @@ impl<'a, C, NC, A> CommentRemoveContentCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CommentRemoveContentCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CommentRemoveContentCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6957,10 +6953,10 @@ impl<'a, C, NC, A> CommentRemoveContentCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct CommentListByBlogCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CommentListByBlogCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _blog_id: String, _status: Vec, _start_date: Option, @@ -6973,9 +6969,9 @@ pub struct CommentListByBlogCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CommentListByBlogCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CommentListByBlogCall<'a, C, A> {} -impl<'a, C, NC, A> CommentListByBlogCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CommentListByBlogCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7129,7 +7125,7 @@ impl<'a, C, NC, A> CommentListByBlogCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// ID of the blog to fetch comments from. - pub fn blog_id(mut self, new_value: &str) -> CommentListByBlogCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> CommentListByBlogCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -7137,7 +7133,7 @@ impl<'a, C, NC, A> CommentListByBlogCall<'a, C, NC, A> where NC: hyper::net::Net /// Each appended value will retain its original ordering and be '/'-separated in the URL's parameters. /// /// - pub fn add_status(mut self, new_value: &str) -> CommentListByBlogCall<'a, C, NC, A> { + pub fn add_status(mut self, new_value: &str) -> CommentListByBlogCall<'a, C, A> { self._status.push(new_value.to_string()); self } @@ -7145,7 +7141,7 @@ impl<'a, C, NC, A> CommentListByBlogCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Earliest date of comment to fetch, a date-time with RFC 3339 formatting. - pub fn start_date(mut self, new_value: &str) -> CommentListByBlogCall<'a, C, NC, A> { + pub fn start_date(mut self, new_value: &str) -> CommentListByBlogCall<'a, C, A> { self._start_date = Some(new_value.to_string()); self } @@ -7153,7 +7149,7 @@ impl<'a, C, NC, A> CommentListByBlogCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Continuation token if request is paged. - pub fn page_token(mut self, new_value: &str) -> CommentListByBlogCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> CommentListByBlogCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -7161,7 +7157,7 @@ impl<'a, C, NC, A> CommentListByBlogCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Maximum number of comments to include in the result. - pub fn max_results(mut self, new_value: u32) -> CommentListByBlogCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> CommentListByBlogCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -7169,7 +7165,7 @@ impl<'a, C, NC, A> CommentListByBlogCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Whether the body content of the comments is included. - pub fn fetch_bodies(mut self, new_value: bool) -> CommentListByBlogCall<'a, C, NC, A> { + pub fn fetch_bodies(mut self, new_value: bool) -> CommentListByBlogCall<'a, C, A> { self._fetch_bodies = Some(new_value); self } @@ -7177,7 +7173,7 @@ impl<'a, C, NC, A> CommentListByBlogCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Latest date of comment to fetch, a date-time with RFC 3339 formatting. - pub fn end_date(mut self, new_value: &str) -> CommentListByBlogCall<'a, C, NC, A> { + pub fn end_date(mut self, new_value: &str) -> CommentListByBlogCall<'a, C, A> { self._end_date = Some(new_value.to_string()); self } @@ -7188,7 +7184,7 @@ impl<'a, C, NC, A> CommentListByBlogCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentListByBlogCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentListByBlogCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7209,7 +7205,7 @@ impl<'a, C, NC, A> CommentListByBlogCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CommentListByBlogCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CommentListByBlogCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7226,7 +7222,7 @@ impl<'a, C, NC, A> CommentListByBlogCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CommentListByBlogCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CommentListByBlogCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7264,10 +7260,10 @@ impl<'a, C, NC, A> CommentListByBlogCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct CommentMarkAsSpamCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CommentMarkAsSpamCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _blog_id: String, _post_id: String, _comment_id: String, @@ -7276,9 +7272,9 @@ pub struct CommentMarkAsSpamCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CommentMarkAsSpamCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CommentMarkAsSpamCall<'a, C, A> {} -impl<'a, C, NC, A> CommentMarkAsSpamCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CommentMarkAsSpamCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7412,7 +7408,7 @@ impl<'a, C, NC, A> CommentMarkAsSpamCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the Blog. - pub fn blog_id(mut self, new_value: &str) -> CommentMarkAsSpamCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> CommentMarkAsSpamCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -7422,7 +7418,7 @@ impl<'a, C, NC, A> CommentMarkAsSpamCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the Post. - pub fn post_id(mut self, new_value: &str) -> CommentMarkAsSpamCall<'a, C, NC, A> { + pub fn post_id(mut self, new_value: &str) -> CommentMarkAsSpamCall<'a, C, A> { self._post_id = new_value.to_string(); self } @@ -7432,7 +7428,7 @@ impl<'a, C, NC, A> CommentMarkAsSpamCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the comment to mark as spam. - pub fn comment_id(mut self, new_value: &str) -> CommentMarkAsSpamCall<'a, C, NC, A> { + pub fn comment_id(mut self, new_value: &str) -> CommentMarkAsSpamCall<'a, C, A> { self._comment_id = new_value.to_string(); self } @@ -7443,7 +7439,7 @@ impl<'a, C, NC, A> CommentMarkAsSpamCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentMarkAsSpamCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentMarkAsSpamCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7464,7 +7460,7 @@ impl<'a, C, NC, A> CommentMarkAsSpamCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CommentMarkAsSpamCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CommentMarkAsSpamCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7481,7 +7477,7 @@ impl<'a, C, NC, A> CommentMarkAsSpamCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CommentMarkAsSpamCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CommentMarkAsSpamCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7526,10 +7522,10 @@ impl<'a, C, NC, A> CommentMarkAsSpamCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct CommentListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CommentListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _blog_id: String, _post_id: String, _view: Option, @@ -7544,9 +7540,9 @@ pub struct CommentListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CommentListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CommentListCall<'a, C, A> {} -impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CommentListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7704,7 +7700,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// ID of the blog to fetch comments from. - pub fn blog_id(mut self, new_value: &str) -> CommentListCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> CommentListCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -7714,7 +7710,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// ID of the post to fetch posts from. - pub fn post_id(mut self, new_value: &str) -> CommentListCall<'a, C, NC, A> { + pub fn post_id(mut self, new_value: &str) -> CommentListCall<'a, C, A> { self._post_id = new_value.to_string(); self } @@ -7722,7 +7718,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Access level with which to view the returned result. Note that some fields require elevated access. - pub fn view(mut self, new_value: &str) -> CommentListCall<'a, C, NC, A> { + pub fn view(mut self, new_value: &str) -> CommentListCall<'a, C, A> { self._view = Some(new_value.to_string()); self } @@ -7730,7 +7726,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Each appended value will retain its original ordering and be '/'-separated in the URL's parameters. /// /// - pub fn add_status(mut self, new_value: &str) -> CommentListCall<'a, C, NC, A> { + pub fn add_status(mut self, new_value: &str) -> CommentListCall<'a, C, A> { self._status.push(new_value.to_string()); self } @@ -7738,7 +7734,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Earliest date of comment to fetch, a date-time with RFC 3339 formatting. - pub fn start_date(mut self, new_value: &str) -> CommentListCall<'a, C, NC, A> { + pub fn start_date(mut self, new_value: &str) -> CommentListCall<'a, C, A> { self._start_date = Some(new_value.to_string()); self } @@ -7746,7 +7742,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Continuation token if request is paged. - pub fn page_token(mut self, new_value: &str) -> CommentListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> CommentListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -7754,7 +7750,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Maximum number of comments to include in the result. - pub fn max_results(mut self, new_value: u32) -> CommentListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> CommentListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -7762,7 +7758,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Whether the body content of the comments is included. - pub fn fetch_bodies(mut self, new_value: bool) -> CommentListCall<'a, C, NC, A> { + pub fn fetch_bodies(mut self, new_value: bool) -> CommentListCall<'a, C, A> { self._fetch_bodies = Some(new_value); self } @@ -7770,7 +7766,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Latest date of comment to fetch, a date-time with RFC 3339 formatting. - pub fn end_date(mut self, new_value: &str) -> CommentListCall<'a, C, NC, A> { + pub fn end_date(mut self, new_value: &str) -> CommentListCall<'a, C, A> { self._end_date = Some(new_value.to_string()); self } @@ -7781,7 +7777,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7802,7 +7798,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CommentListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CommentListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7819,7 +7815,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CommentListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CommentListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7857,10 +7853,10 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct CommentApproveCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CommentApproveCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _blog_id: String, _post_id: String, _comment_id: String, @@ -7869,9 +7865,9 @@ pub struct CommentApproveCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CommentApproveCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CommentApproveCall<'a, C, A> {} -impl<'a, C, NC, A> CommentApproveCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CommentApproveCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8005,7 +8001,7 @@ impl<'a, C, NC, A> CommentApproveCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the Blog. - pub fn blog_id(mut self, new_value: &str) -> CommentApproveCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> CommentApproveCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -8015,7 +8011,7 @@ impl<'a, C, NC, A> CommentApproveCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the Post. - pub fn post_id(mut self, new_value: &str) -> CommentApproveCall<'a, C, NC, A> { + pub fn post_id(mut self, new_value: &str) -> CommentApproveCall<'a, C, A> { self._post_id = new_value.to_string(); self } @@ -8025,7 +8021,7 @@ impl<'a, C, NC, A> CommentApproveCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the comment to mark as not spam. - pub fn comment_id(mut self, new_value: &str) -> CommentApproveCall<'a, C, NC, A> { + pub fn comment_id(mut self, new_value: &str) -> CommentApproveCall<'a, C, A> { self._comment_id = new_value.to_string(); self } @@ -8036,7 +8032,7 @@ impl<'a, C, NC, A> CommentApproveCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentApproveCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentApproveCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8057,7 +8053,7 @@ impl<'a, C, NC, A> CommentApproveCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CommentApproveCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CommentApproveCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8074,7 +8070,7 @@ impl<'a, C, NC, A> CommentApproveCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CommentApproveCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CommentApproveCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8112,10 +8108,10 @@ impl<'a, C, NC, A> CommentApproveCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct CommentDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CommentDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _blog_id: String, _post_id: String, _comment_id: String, @@ -8124,9 +8120,9 @@ pub struct CommentDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CommentDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CommentDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> CommentDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CommentDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8249,7 +8245,7 @@ impl<'a, C, NC, A> CommentDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the Blog. - pub fn blog_id(mut self, new_value: &str) -> CommentDeleteCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> CommentDeleteCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -8259,7 +8255,7 @@ impl<'a, C, NC, A> CommentDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the Post. - pub fn post_id(mut self, new_value: &str) -> CommentDeleteCall<'a, C, NC, A> { + pub fn post_id(mut self, new_value: &str) -> CommentDeleteCall<'a, C, A> { self._post_id = new_value.to_string(); self } @@ -8269,7 +8265,7 @@ impl<'a, C, NC, A> CommentDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the comment to delete. - pub fn comment_id(mut self, new_value: &str) -> CommentDeleteCall<'a, C, NC, A> { + pub fn comment_id(mut self, new_value: &str) -> CommentDeleteCall<'a, C, A> { self._comment_id = new_value.to_string(); self } @@ -8280,7 +8276,7 @@ impl<'a, C, NC, A> CommentDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8301,7 +8297,7 @@ impl<'a, C, NC, A> CommentDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CommentDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CommentDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8318,7 +8314,7 @@ impl<'a, C, NC, A> CommentDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CommentDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CommentDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8357,10 +8353,10 @@ impl<'a, C, NC, A> CommentDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct PostUserInfoGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PostUserInfoGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _user_id: String, _blog_id: String, _post_id: String, @@ -8370,9 +8366,9 @@ pub struct PostUserInfoGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PostUserInfoGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PostUserInfoGetCall<'a, C, A> {} -impl<'a, C, NC, A> PostUserInfoGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PostUserInfoGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8509,7 +8505,7 @@ impl<'a, C, NC, A> PostUserInfoGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// ID of the user for the per-user information to be fetched. Either the word 'self' (sans quote marks) or the user's profile identifier. - pub fn user_id(mut self, new_value: &str) -> PostUserInfoGetCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> PostUserInfoGetCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -8519,7 +8515,7 @@ impl<'a, C, NC, A> PostUserInfoGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the blog. - pub fn blog_id(mut self, new_value: &str) -> PostUserInfoGetCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> PostUserInfoGetCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -8529,7 +8525,7 @@ impl<'a, C, NC, A> PostUserInfoGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the post to get. - pub fn post_id(mut self, new_value: &str) -> PostUserInfoGetCall<'a, C, NC, A> { + pub fn post_id(mut self, new_value: &str) -> PostUserInfoGetCall<'a, C, A> { self._post_id = new_value.to_string(); self } @@ -8537,7 +8533,7 @@ impl<'a, C, NC, A> PostUserInfoGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Maximum number of comments to pull back on a post. - pub fn max_comments(mut self, new_value: u32) -> PostUserInfoGetCall<'a, C, NC, A> { + pub fn max_comments(mut self, new_value: u32) -> PostUserInfoGetCall<'a, C, A> { self._max_comments = Some(new_value); self } @@ -8548,7 +8544,7 @@ impl<'a, C, NC, A> PostUserInfoGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostUserInfoGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostUserInfoGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8569,7 +8565,7 @@ impl<'a, C, NC, A> PostUserInfoGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PostUserInfoGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PostUserInfoGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8586,7 +8582,7 @@ impl<'a, C, NC, A> PostUserInfoGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PostUserInfoGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PostUserInfoGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8633,10 +8629,10 @@ impl<'a, C, NC, A> PostUserInfoGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct PostUserInfoListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PostUserInfoListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _user_id: String, _blog_id: String, _view: Option, @@ -8653,9 +8649,9 @@ pub struct PostUserInfoListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PostUserInfoListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PostUserInfoListCall<'a, C, A> {} -impl<'a, C, NC, A> PostUserInfoListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PostUserInfoListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8819,7 +8815,7 @@ impl<'a, C, NC, A> PostUserInfoListCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// ID of the user for the per-user information to be fetched. Either the word 'self' (sans quote marks) or the user's profile identifier. - pub fn user_id(mut self, new_value: &str) -> PostUserInfoListCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> PostUserInfoListCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -8829,7 +8825,7 @@ impl<'a, C, NC, A> PostUserInfoListCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// ID of the blog to fetch posts from. - pub fn blog_id(mut self, new_value: &str) -> PostUserInfoListCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> PostUserInfoListCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -8837,7 +8833,7 @@ impl<'a, C, NC, A> PostUserInfoListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Access level with which to view the returned result. Note that some fields require elevated access. - pub fn view(mut self, new_value: &str) -> PostUserInfoListCall<'a, C, NC, A> { + pub fn view(mut self, new_value: &str) -> PostUserInfoListCall<'a, C, A> { self._view = Some(new_value.to_string()); self } @@ -8845,7 +8841,7 @@ impl<'a, C, NC, A> PostUserInfoListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Each appended value will retain its original ordering and be '/'-separated in the URL's parameters. /// /// - pub fn add_status(mut self, new_value: &str) -> PostUserInfoListCall<'a, C, NC, A> { + pub fn add_status(mut self, new_value: &str) -> PostUserInfoListCall<'a, C, A> { self._status.push(new_value.to_string()); self } @@ -8853,7 +8849,7 @@ impl<'a, C, NC, A> PostUserInfoListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Earliest post date to fetch, a date-time with RFC 3339 formatting. - pub fn start_date(mut self, new_value: &str) -> PostUserInfoListCall<'a, C, NC, A> { + pub fn start_date(mut self, new_value: &str) -> PostUserInfoListCall<'a, C, A> { self._start_date = Some(new_value.to_string()); self } @@ -8861,7 +8857,7 @@ impl<'a, C, NC, A> PostUserInfoListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Continuation token if the request is paged. - pub fn page_token(mut self, new_value: &str) -> PostUserInfoListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> PostUserInfoListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -8869,7 +8865,7 @@ impl<'a, C, NC, A> PostUserInfoListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Sort order applied to search results. Default is published. - pub fn order_by(mut self, new_value: &str) -> PostUserInfoListCall<'a, C, NC, A> { + pub fn order_by(mut self, new_value: &str) -> PostUserInfoListCall<'a, C, A> { self._order_by = Some(new_value.to_string()); self } @@ -8877,7 +8873,7 @@ impl<'a, C, NC, A> PostUserInfoListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Maximum number of posts to fetch. - pub fn max_results(mut self, new_value: u32) -> PostUserInfoListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> PostUserInfoListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -8885,7 +8881,7 @@ impl<'a, C, NC, A> PostUserInfoListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Comma-separated list of labels to search for. - pub fn labels(mut self, new_value: &str) -> PostUserInfoListCall<'a, C, NC, A> { + pub fn labels(mut self, new_value: &str) -> PostUserInfoListCall<'a, C, A> { self._labels = Some(new_value.to_string()); self } @@ -8893,7 +8889,7 @@ impl<'a, C, NC, A> PostUserInfoListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Whether the body content of posts is included. Default is false. - pub fn fetch_bodies(mut self, new_value: bool) -> PostUserInfoListCall<'a, C, NC, A> { + pub fn fetch_bodies(mut self, new_value: bool) -> PostUserInfoListCall<'a, C, A> { self._fetch_bodies = Some(new_value); self } @@ -8901,7 +8897,7 @@ impl<'a, C, NC, A> PostUserInfoListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Latest post date to fetch, a date-time with RFC 3339 formatting. - pub fn end_date(mut self, new_value: &str) -> PostUserInfoListCall<'a, C, NC, A> { + pub fn end_date(mut self, new_value: &str) -> PostUserInfoListCall<'a, C, A> { self._end_date = Some(new_value.to_string()); self } @@ -8912,7 +8908,7 @@ impl<'a, C, NC, A> PostUserInfoListCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostUserInfoListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostUserInfoListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8933,7 +8929,7 @@ impl<'a, C, NC, A> PostUserInfoListCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PostUserInfoListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PostUserInfoListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8950,7 +8946,7 @@ impl<'a, C, NC, A> PostUserInfoListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PostUserInfoListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PostUserInfoListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8989,10 +8985,10 @@ impl<'a, C, NC, A> PostUserInfoListCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct BlogUserInfoGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BlogUserInfoGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _user_id: String, _blog_id: String, _max_posts: Option, @@ -9001,9 +8997,9 @@ pub struct BlogUserInfoGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BlogUserInfoGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BlogUserInfoGetCall<'a, C, A> {} -impl<'a, C, NC, A> BlogUserInfoGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BlogUserInfoGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9139,7 +9135,7 @@ impl<'a, C, NC, A> BlogUserInfoGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// ID of the user whose blogs are to be fetched. Either the word 'self' (sans quote marks) or the user's profile identifier. - pub fn user_id(mut self, new_value: &str) -> BlogUserInfoGetCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> BlogUserInfoGetCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -9149,7 +9145,7 @@ impl<'a, C, NC, A> BlogUserInfoGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the blog to get. - pub fn blog_id(mut self, new_value: &str) -> BlogUserInfoGetCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> BlogUserInfoGetCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -9157,7 +9153,7 @@ impl<'a, C, NC, A> BlogUserInfoGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Maximum number of posts to pull back with the blog. - pub fn max_posts(mut self, new_value: u32) -> BlogUserInfoGetCall<'a, C, NC, A> { + pub fn max_posts(mut self, new_value: u32) -> BlogUserInfoGetCall<'a, C, A> { self._max_posts = Some(new_value); self } @@ -9168,7 +9164,7 @@ impl<'a, C, NC, A> BlogUserInfoGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BlogUserInfoGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BlogUserInfoGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9189,7 +9185,7 @@ impl<'a, C, NC, A> BlogUserInfoGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BlogUserInfoGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BlogUserInfoGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9206,7 +9202,7 @@ impl<'a, C, NC, A> BlogUserInfoGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BlogUserInfoGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BlogUserInfoGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9245,10 +9241,10 @@ impl<'a, C, NC, A> BlogUserInfoGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct PageGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PageGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _blog_id: String, _page_id: String, _view: Option, @@ -9257,9 +9253,9 @@ pub struct PageGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PageGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PageGetCall<'a, C, A> {} -impl<'a, C, NC, A> PageGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PageGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9395,7 +9391,7 @@ impl<'a, C, NC, A> PageGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// ID of the blog containing the page. - pub fn blog_id(mut self, new_value: &str) -> PageGetCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> PageGetCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -9405,14 +9401,14 @@ impl<'a, C, NC, A> PageGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// The ID of the page to get. - pub fn page_id(mut self, new_value: &str) -> PageGetCall<'a, C, NC, A> { + pub fn page_id(mut self, new_value: &str) -> PageGetCall<'a, C, A> { self._page_id = new_value.to_string(); self } /// Sets the *view* query property to the given value. /// /// - pub fn view(mut self, new_value: &str) -> PageGetCall<'a, C, NC, A> { + pub fn view(mut self, new_value: &str) -> PageGetCall<'a, C, A> { self._view = Some(new_value.to_string()); self } @@ -9423,7 +9419,7 @@ impl<'a, C, NC, A> PageGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PageGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PageGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9444,7 +9440,7 @@ impl<'a, C, NC, A> PageGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PageGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PageGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9461,7 +9457,7 @@ impl<'a, C, NC, A> PageGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PageGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PageGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9504,10 +9500,10 @@ impl<'a, C, NC, A> PageGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct PageListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PageListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _blog_id: String, _view: Option, _status: Vec, @@ -9519,9 +9515,9 @@ pub struct PageListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PageListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PageListCall<'a, C, A> {} -impl<'a, C, NC, A> PageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PageListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9672,7 +9668,7 @@ impl<'a, C, NC, A> PageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// ID of the blog to fetch Pages from. - pub fn blog_id(mut self, new_value: &str) -> PageListCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> PageListCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -9680,7 +9676,7 @@ impl<'a, C, NC, A> PageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Access level with which to view the returned result. Note that some fields require elevated access. - pub fn view(mut self, new_value: &str) -> PageListCall<'a, C, NC, A> { + pub fn view(mut self, new_value: &str) -> PageListCall<'a, C, A> { self._view = Some(new_value.to_string()); self } @@ -9688,7 +9684,7 @@ impl<'a, C, NC, A> PageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Each appended value will retain its original ordering and be '/'-separated in the URL's parameters. /// /// - pub fn add_status(mut self, new_value: &str) -> PageListCall<'a, C, NC, A> { + pub fn add_status(mut self, new_value: &str) -> PageListCall<'a, C, A> { self._status.push(new_value.to_string()); self } @@ -9696,7 +9692,7 @@ impl<'a, C, NC, A> PageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Continuation token if the request is paged. - pub fn page_token(mut self, new_value: &str) -> PageListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> PageListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -9704,7 +9700,7 @@ impl<'a, C, NC, A> PageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Maximum number of Pages to fetch. - pub fn max_results(mut self, new_value: u32) -> PageListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> PageListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -9712,7 +9708,7 @@ impl<'a, C, NC, A> PageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Whether to retrieve the Page bodies. - pub fn fetch_bodies(mut self, new_value: bool) -> PageListCall<'a, C, NC, A> { + pub fn fetch_bodies(mut self, new_value: bool) -> PageListCall<'a, C, A> { self._fetch_bodies = Some(new_value); self } @@ -9723,7 +9719,7 @@ impl<'a, C, NC, A> PageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PageListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PageListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9744,7 +9740,7 @@ impl<'a, C, NC, A> PageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PageListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PageListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9761,7 +9757,7 @@ impl<'a, C, NC, A> PageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PageListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PageListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9799,10 +9795,10 @@ impl<'a, C, NC, A> PageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct PageRevertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PageRevertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _blog_id: String, _page_id: String, _delegate: Option<&'a mut Delegate>, @@ -9810,9 +9806,9 @@ pub struct PageRevertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PageRevertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PageRevertCall<'a, C, A> {} -impl<'a, C, NC, A> PageRevertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PageRevertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9945,7 +9941,7 @@ impl<'a, C, NC, A> PageRevertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the blog. - pub fn blog_id(mut self, new_value: &str) -> PageRevertCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> PageRevertCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -9955,7 +9951,7 @@ impl<'a, C, NC, A> PageRevertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the page. - pub fn page_id(mut self, new_value: &str) -> PageRevertCall<'a, C, NC, A> { + pub fn page_id(mut self, new_value: &str) -> PageRevertCall<'a, C, A> { self._page_id = new_value.to_string(); self } @@ -9966,7 +9962,7 @@ impl<'a, C, NC, A> PageRevertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PageRevertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PageRevertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9987,7 +9983,7 @@ impl<'a, C, NC, A> PageRevertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PageRevertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PageRevertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10004,7 +10000,7 @@ impl<'a, C, NC, A> PageRevertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PageRevertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PageRevertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10049,10 +10045,10 @@ impl<'a, C, NC, A> PageRevertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct PageInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PageInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _request: Page, _blog_id: String, _is_draft: Option, @@ -10061,9 +10057,9 @@ pub struct PageInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PageInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PageInsertCall<'a, C, A> {} -impl<'a, C, NC, A> PageInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PageInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10205,7 +10201,7 @@ impl<'a, C, NC, A> PageInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Page) -> PageInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Page) -> PageInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -10215,7 +10211,7 @@ impl<'a, C, NC, A> PageInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// ID of the blog to add the page to. - pub fn blog_id(mut self, new_value: &str) -> PageInsertCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> PageInsertCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -10223,7 +10219,7 @@ impl<'a, C, NC, A> PageInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether to create the page as a draft (default: false). - pub fn is_draft(mut self, new_value: bool) -> PageInsertCall<'a, C, NC, A> { + pub fn is_draft(mut self, new_value: bool) -> PageInsertCall<'a, C, A> { self._is_draft = Some(new_value); self } @@ -10234,7 +10230,7 @@ impl<'a, C, NC, A> PageInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PageInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PageInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10255,7 +10251,7 @@ impl<'a, C, NC, A> PageInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PageInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PageInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10272,7 +10268,7 @@ impl<'a, C, NC, A> PageInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PageInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PageInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10318,10 +10314,10 @@ impl<'a, C, NC, A> PageInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct PagePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PagePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _request: Page, _blog_id: String, _page_id: String, @@ -10332,9 +10328,9 @@ pub struct PagePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PagePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PagePatchCall<'a, C, A> {} -impl<'a, C, NC, A> PagePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PagePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10480,7 +10476,7 @@ impl<'a, C, NC, A> PagePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Page) -> PagePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Page) -> PagePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -10490,7 +10486,7 @@ impl<'a, C, NC, A> PagePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the Blog. - pub fn blog_id(mut self, new_value: &str) -> PagePatchCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> PagePatchCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -10500,7 +10496,7 @@ impl<'a, C, NC, A> PagePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the Page. - pub fn page_id(mut self, new_value: &str) -> PagePatchCall<'a, C, NC, A> { + pub fn page_id(mut self, new_value: &str) -> PagePatchCall<'a, C, A> { self._page_id = new_value.to_string(); self } @@ -10508,7 +10504,7 @@ impl<'a, C, NC, A> PagePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether a revert action should be performed when the page is updated (default: false). - pub fn revert(mut self, new_value: bool) -> PagePatchCall<'a, C, NC, A> { + pub fn revert(mut self, new_value: bool) -> PagePatchCall<'a, C, A> { self._revert = Some(new_value); self } @@ -10516,7 +10512,7 @@ impl<'a, C, NC, A> PagePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether a publish action should be performed when the page is updated (default: false). - pub fn publish(mut self, new_value: bool) -> PagePatchCall<'a, C, NC, A> { + pub fn publish(mut self, new_value: bool) -> PagePatchCall<'a, C, A> { self._publish = Some(new_value); self } @@ -10527,7 +10523,7 @@ impl<'a, C, NC, A> PagePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PagePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PagePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10548,7 +10544,7 @@ impl<'a, C, NC, A> PagePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PagePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PagePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10565,7 +10561,7 @@ impl<'a, C, NC, A> PagePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PagePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PagePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10603,10 +10599,10 @@ impl<'a, C, NC, A> PagePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct PagePublishCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PagePublishCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _blog_id: String, _page_id: String, _delegate: Option<&'a mut Delegate>, @@ -10614,9 +10610,9 @@ pub struct PagePublishCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PagePublishCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PagePublishCall<'a, C, A> {} -impl<'a, C, NC, A> PagePublishCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PagePublishCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10749,7 +10745,7 @@ impl<'a, C, NC, A> PagePublishCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the blog. - pub fn blog_id(mut self, new_value: &str) -> PagePublishCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> PagePublishCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -10759,7 +10755,7 @@ impl<'a, C, NC, A> PagePublishCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the page. - pub fn page_id(mut self, new_value: &str) -> PagePublishCall<'a, C, NC, A> { + pub fn page_id(mut self, new_value: &str) -> PagePublishCall<'a, C, A> { self._page_id = new_value.to_string(); self } @@ -10770,7 +10766,7 @@ impl<'a, C, NC, A> PagePublishCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PagePublishCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PagePublishCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10791,7 +10787,7 @@ impl<'a, C, NC, A> PagePublishCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PagePublishCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PagePublishCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10808,7 +10804,7 @@ impl<'a, C, NC, A> PagePublishCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PagePublishCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PagePublishCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10854,10 +10850,10 @@ impl<'a, C, NC, A> PagePublishCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct PageUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PageUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _request: Page, _blog_id: String, _page_id: String, @@ -10868,9 +10864,9 @@ pub struct PageUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PageUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PageUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> PageUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PageUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11016,7 +11012,7 @@ impl<'a, C, NC, A> PageUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Page) -> PageUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Page) -> PageUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -11026,7 +11022,7 @@ impl<'a, C, NC, A> PageUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the Blog. - pub fn blog_id(mut self, new_value: &str) -> PageUpdateCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> PageUpdateCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -11036,7 +11032,7 @@ impl<'a, C, NC, A> PageUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the Page. - pub fn page_id(mut self, new_value: &str) -> PageUpdateCall<'a, C, NC, A> { + pub fn page_id(mut self, new_value: &str) -> PageUpdateCall<'a, C, A> { self._page_id = new_value.to_string(); self } @@ -11044,7 +11040,7 @@ impl<'a, C, NC, A> PageUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether a revert action should be performed when the page is updated (default: false). - pub fn revert(mut self, new_value: bool) -> PageUpdateCall<'a, C, NC, A> { + pub fn revert(mut self, new_value: bool) -> PageUpdateCall<'a, C, A> { self._revert = Some(new_value); self } @@ -11052,7 +11048,7 @@ impl<'a, C, NC, A> PageUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether a publish action should be performed when the page is updated (default: false). - pub fn publish(mut self, new_value: bool) -> PageUpdateCall<'a, C, NC, A> { + pub fn publish(mut self, new_value: bool) -> PageUpdateCall<'a, C, A> { self._publish = Some(new_value); self } @@ -11063,7 +11059,7 @@ impl<'a, C, NC, A> PageUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PageUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PageUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11084,7 +11080,7 @@ impl<'a, C, NC, A> PageUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PageUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PageUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11101,7 +11097,7 @@ impl<'a, C, NC, A> PageUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PageUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PageUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11139,10 +11135,10 @@ impl<'a, C, NC, A> PageUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct PageDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PageDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Blogger, + hub: &'a Blogger, _blog_id: String, _page_id: String, _delegate: Option<&'a mut Delegate>, @@ -11150,9 +11146,9 @@ pub struct PageDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PageDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PageDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> PageDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PageDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11274,7 +11270,7 @@ impl<'a, C, NC, A> PageDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the Blog. - pub fn blog_id(mut self, new_value: &str) -> PageDeleteCall<'a, C, NC, A> { + pub fn blog_id(mut self, new_value: &str) -> PageDeleteCall<'a, C, A> { self._blog_id = new_value.to_string(); self } @@ -11284,7 +11280,7 @@ impl<'a, C, NC, A> PageDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the Page. - pub fn page_id(mut self, new_value: &str) -> PageDeleteCall<'a, C, NC, A> { + pub fn page_id(mut self, new_value: &str) -> PageDeleteCall<'a, C, A> { self._page_id = new_value.to_string(); self } @@ -11295,7 +11291,7 @@ impl<'a, C, NC, A> PageDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PageDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PageDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11316,7 +11312,7 @@ impl<'a, C, NC, A> PageDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PageDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PageDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11333,7 +11329,7 @@ impl<'a, C, NC, A> PageDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PageDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PageDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/books1/Cargo.toml b/gen/books1/Cargo.toml index e870879282a..343b5a06e3b 100644 --- a/gen/books1/Cargo.toml +++ b/gen/books1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-books1" -version = "0.1.4+20150309" +version = "0.1.5+20150309" authors = ["Sebastian Thiel "] description = "A complete library to interact with books (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/books1" homepage = "https://developers.google.com/books/docs/v1/getting_started" -documentation = "http://byron.github.io/google-apis-rs/google-books1" +documentation = "http://byron.github.io/google-apis-rs/google_books1" license = "MIT" keywords = ["books", "google", "protocol", "web", "api"] diff --git a/gen/books1/README.md b/gen/books1/README.md index 60f5b6fc44f..bd22bc7402c 100644 --- a/gen/books1/README.md +++ b/gen/books1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-books1` library allows access to all features of the *Google books* service. -This documentation was generated from *books* crate version *0.1.4+20150309*, where *20150309* is the exact revision of the *books:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *books* crate version *0.1.5+20150309*, where *20150309* is the exact revision of the *books:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *books* *v1* API can be found at the [official documentation site](https://developers.google.com/books/docs/v1/getting_started). diff --git a/gen/books1/src/cmn.rs b/gen/books1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/books1/src/cmn.rs +++ b/gen/books1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/books1/src/lib.rs b/gen/books1/src/lib.rs index 0664e5876cf..c15c48ec7b4 100644 --- a/gen/books1/src/lib.rs +++ b/gen/books1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *books* crate version *0.1.4+20150309*, where *20150309* is the exact revision of the *books:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *books* crate version *0.1.5+20150309*, where *20150309* is the exact revision of the *books:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *books* *v1* API can be found at the //! [official documentation site](https://developers.google.com/books/docs/v1/getting_started). @@ -223,7 +223,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -326,58 +325,55 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Books { +pub struct Books { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Books {} +impl<'a, C, A> Hub for Books {} -impl<'a, C, NC, A> Books - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Books + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Books { + pub fn new(client: C, authenticator: A) -> Books { Books { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn bookshelves(&'a self) -> BookshelveMethods<'a, C, NC, A> { + pub fn bookshelves(&'a self) -> BookshelveMethods<'a, C, A> { BookshelveMethods { hub: &self } } - pub fn cloudloading(&'a self) -> CloudloadingMethods<'a, C, NC, A> { + pub fn cloudloading(&'a self) -> CloudloadingMethods<'a, C, A> { CloudloadingMethods { hub: &self } } - pub fn dictionary(&'a self) -> DictionaryMethods<'a, C, NC, A> { + pub fn dictionary(&'a self) -> DictionaryMethods<'a, C, A> { DictionaryMethods { hub: &self } } - pub fn layers(&'a self) -> LayerMethods<'a, C, NC, A> { + pub fn layers(&'a self) -> LayerMethods<'a, C, A> { LayerMethods { hub: &self } } - pub fn myconfig(&'a self) -> MyconfigMethods<'a, C, NC, A> { + pub fn myconfig(&'a self) -> MyconfigMethods<'a, C, A> { MyconfigMethods { hub: &self } } - pub fn mylibrary(&'a self) -> MylibraryMethods<'a, C, NC, A> { + pub fn mylibrary(&'a self) -> MylibraryMethods<'a, C, A> { MylibraryMethods { hub: &self } } - pub fn onboarding(&'a self) -> OnboardingMethods<'a, C, NC, A> { + pub fn onboarding(&'a self) -> OnboardingMethods<'a, C, A> { OnboardingMethods { hub: &self } } - pub fn promooffer(&'a self) -> PromoofferMethods<'a, C, NC, A> { + pub fn promooffer(&'a self) -> PromoofferMethods<'a, C, A> { PromoofferMethods { hub: &self } } - pub fn volumes(&'a self) -> VolumeMethods<'a, C, NC, A> { + pub fn volumes(&'a self) -> VolumeMethods<'a, C, A> { VolumeMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -2060,15 +2056,15 @@ impl Part for VolumeSaleInfoOffersRentalDuration {} /// let rb = hub.layers(); /// # } /// ``` -pub struct LayerMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LayerMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, } -impl<'a, C, NC, A> MethodsBuilder for LayerMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for LayerMethods<'a, C, A> {} -impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { +impl<'a, C, A> LayerMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2080,7 +2076,7 @@ impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { /// * `layerId` - The ID for the layer to get the annotations. /// * `annotationDataId` - The ID of the annotation data to retrieve. /// * `contentVersion` - The content version for the volume you are trying to retrieve. - pub fn annotation_data_get(&self, volume_id: &str, layer_id: &str, annotation_data_id: &str, content_version: &str) -> LayerAnnotationDataGetCall<'a, C, NC, A> { + pub fn annotation_data_get(&self, volume_id: &str, layer_id: &str, annotation_data_id: &str, content_version: &str) -> LayerAnnotationDataGetCall<'a, C, A> { LayerAnnotationDataGetCall { hub: self.hub, _volume_id: volume_id.to_string(), @@ -2108,7 +2104,7 @@ impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { /// * `volumeId` - The volume to retrieve annotations for. /// * `layerId` - The ID for the layer to get the annotations. /// * `annotationId` - The ID of the volume annotation to retrieve. - pub fn volume_annotations_get(&self, volume_id: &str, layer_id: &str, annotation_id: &str) -> LayerVolumeAnnotationGetCall<'a, C, NC, A> { + pub fn volume_annotations_get(&self, volume_id: &str, layer_id: &str, annotation_id: &str) -> LayerVolumeAnnotationGetCall<'a, C, A> { LayerVolumeAnnotationGetCall { hub: self.hub, _volume_id: volume_id.to_string(), @@ -2129,7 +2125,7 @@ impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { /// # Arguments /// /// * `volumeId` - The volume to retrieve layers for. - pub fn list(&self, volume_id: &str) -> LayerListCall<'a, C, NC, A> { + pub fn list(&self, volume_id: &str) -> LayerListCall<'a, C, A> { LayerListCall { hub: self.hub, _volume_id: volume_id.to_string(), @@ -2151,7 +2147,7 @@ impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { /// /// * `volumeId` - The volume to retrieve layers for. /// * `summaryId` - The ID for the layer to get the summary for. - pub fn get(&self, volume_id: &str, summary_id: &str) -> LayerGetCall<'a, C, NC, A> { + pub fn get(&self, volume_id: &str, summary_id: &str) -> LayerGetCall<'a, C, A> { LayerGetCall { hub: self.hub, _volume_id: volume_id.to_string(), @@ -2173,7 +2169,7 @@ impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { /// * `volumeId` - The volume to retrieve annotations for. /// * `layerId` - The ID for the layer to get the annotations. /// * `contentVersion` - The content version for the requested volume. - pub fn volume_annotations_list(&self, volume_id: &str, layer_id: &str, content_version: &str) -> LayerVolumeAnnotationListCall<'a, C, NC, A> { + pub fn volume_annotations_list(&self, volume_id: &str, layer_id: &str, content_version: &str) -> LayerVolumeAnnotationListCall<'a, C, A> { LayerVolumeAnnotationListCall { hub: self.hub, _volume_id: volume_id.to_string(), @@ -2206,7 +2202,7 @@ impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { /// * `volumeId` - The volume to retrieve annotation data for. /// * `layerId` - The ID for the layer to get the annotation data. /// * `contentVersion` - The content version for the requested volume. - pub fn annotation_data_list(&self, volume_id: &str, layer_id: &str, content_version: &str) -> LayerAnnotationDataListCall<'a, C, NC, A> { + pub fn annotation_data_list(&self, volume_id: &str, layer_id: &str, content_version: &str) -> LayerAnnotationDataListCall<'a, C, A> { LayerAnnotationDataListCall { hub: self.hub, _volume_id: volume_id.to_string(), @@ -2259,15 +2255,15 @@ impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { /// let rb = hub.volumes(); /// # } /// ``` -pub struct VolumeMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VolumeMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, } -impl<'a, C, NC, A> MethodsBuilder for VolumeMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for VolumeMethods<'a, C, A> {} -impl<'a, C, NC, A> VolumeMethods<'a, C, NC, A> { +impl<'a, C, A> VolumeMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2277,7 +2273,7 @@ impl<'a, C, NC, A> VolumeMethods<'a, C, NC, A> { /// /// * `rating` - Rating to be given to the volume. /// * `volumeId` - ID of the source volume. - pub fn recommended_rate(&self, rating: &str, volume_id: &str) -> VolumeRecommendedRateCall<'a, C, NC, A> { + pub fn recommended_rate(&self, rating: &str, volume_id: &str) -> VolumeRecommendedRateCall<'a, C, A> { VolumeRecommendedRateCall { hub: self.hub, _rating: rating.to_string(), @@ -2293,7 +2289,7 @@ impl<'a, C, NC, A> VolumeMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Return a list of books in My Library. - pub fn mybooks_list(&self) -> VolumeMybookListCall<'a, C, NC, A> { + pub fn mybooks_list(&self) -> VolumeMybookListCall<'a, C, A> { VolumeMybookListCall { hub: self.hub, _start_index: Default::default(), @@ -2315,7 +2311,7 @@ impl<'a, C, NC, A> VolumeMethods<'a, C, NC, A> { /// # Arguments /// /// * `q` - Full-text search query string. - pub fn list(&self, q: &str) -> VolumeListCall<'a, C, NC, A> { + pub fn list(&self, q: &str) -> VolumeListCall<'a, C, A> { VolumeListCall { hub: self.hub, _q: q.to_string(), @@ -2340,7 +2336,7 @@ impl<'a, C, NC, A> VolumeMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Return a list of books uploaded by the current user. - pub fn useruploaded_list(&self) -> VolumeUseruploadedListCall<'a, C, NC, A> { + pub fn useruploaded_list(&self) -> VolumeUseruploadedListCall<'a, C, A> { VolumeUseruploadedListCall { hub: self.hub, _volume_id: Default::default(), @@ -2362,7 +2358,7 @@ impl<'a, C, NC, A> VolumeMethods<'a, C, NC, A> { /// # Arguments /// /// * `volumeId` - ID of the source volume. - pub fn associated_list(&self, volume_id: &str) -> VolumeAssociatedListCall<'a, C, NC, A> { + pub fn associated_list(&self, volume_id: &str) -> VolumeAssociatedListCall<'a, C, A> { VolumeAssociatedListCall { hub: self.hub, _volume_id: volume_id.to_string(), @@ -2382,7 +2378,7 @@ impl<'a, C, NC, A> VolumeMethods<'a, C, NC, A> { /// # Arguments /// /// * `volumeId` - ID of volume to retrieve. - pub fn get(&self, volume_id: &str) -> VolumeGetCall<'a, C, NC, A> { + pub fn get(&self, volume_id: &str) -> VolumeGetCall<'a, C, A> { VolumeGetCall { hub: self.hub, _volume_id: volume_id.to_string(), @@ -2400,7 +2396,7 @@ impl<'a, C, NC, A> VolumeMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Return a list of recommended books for the current user. - pub fn recommended_list(&self) -> VolumeRecommendedListCall<'a, C, NC, A> { + pub fn recommended_list(&self) -> VolumeRecommendedListCall<'a, C, A> { VolumeRecommendedListCall { hub: self.hub, _source: Default::default(), @@ -2442,15 +2438,15 @@ impl<'a, C, NC, A> VolumeMethods<'a, C, NC, A> { /// let rb = hub.dictionary(); /// # } /// ``` -pub struct DictionaryMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DictionaryMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, } -impl<'a, C, NC, A> MethodsBuilder for DictionaryMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for DictionaryMethods<'a, C, A> {} -impl<'a, C, NC, A> DictionaryMethods<'a, C, NC, A> { +impl<'a, C, A> DictionaryMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2459,7 +2455,7 @@ impl<'a, C, NC, A> DictionaryMethods<'a, C, NC, A> { /// # Arguments /// /// * `cpksver` - The device/version ID from which to request the data. - pub fn list_offline_metadata(&self, cpksver: &str) -> DictionaryListOfflineMetadataCall<'a, C, NC, A> { + pub fn list_offline_metadata(&self, cpksver: &str) -> DictionaryListOfflineMetadataCall<'a, C, A> { DictionaryListOfflineMetadataCall { hub: self.hub, _cpksver: cpksver.to_string(), @@ -2500,15 +2496,15 @@ impl<'a, C, NC, A> DictionaryMethods<'a, C, NC, A> { /// let rb = hub.bookshelves(); /// # } /// ``` -pub struct BookshelveMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BookshelveMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, } -impl<'a, C, NC, A> MethodsBuilder for BookshelveMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for BookshelveMethods<'a, C, A> {} -impl<'a, C, NC, A> BookshelveMethods<'a, C, NC, A> { +impl<'a, C, A> BookshelveMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2518,7 +2514,7 @@ impl<'a, C, NC, A> BookshelveMethods<'a, C, NC, A> { /// /// * `userId` - ID of user for whom to retrieve bookshelf volumes. /// * `shelf` - ID of bookshelf to retrieve volumes. - pub fn volumes_list(&self, user_id: &str, shelf: &str) -> BookshelveVolumeListCall<'a, C, NC, A> { + pub fn volumes_list(&self, user_id: &str, shelf: &str) -> BookshelveVolumeListCall<'a, C, A> { BookshelveVolumeListCall { hub: self.hub, _user_id: user_id.to_string(), @@ -2540,7 +2536,7 @@ impl<'a, C, NC, A> BookshelveMethods<'a, C, NC, A> { /// # Arguments /// /// * `userId` - ID of user for whom to retrieve bookshelves. - pub fn list(&self, user_id: &str) -> BookshelveListCall<'a, C, NC, A> { + pub fn list(&self, user_id: &str) -> BookshelveListCall<'a, C, A> { BookshelveListCall { hub: self.hub, _user_id: user_id.to_string(), @@ -2559,7 +2555,7 @@ impl<'a, C, NC, A> BookshelveMethods<'a, C, NC, A> { /// /// * `userId` - ID of user for whom to retrieve bookshelves. /// * `shelf` - ID of bookshelf to retrieve. - pub fn get(&self, user_id: &str, shelf: &str) -> BookshelveGetCall<'a, C, NC, A> { + pub fn get(&self, user_id: &str, shelf: &str) -> BookshelveGetCall<'a, C, A> { BookshelveGetCall { hub: self.hub, _user_id: user_id.to_string(), @@ -2602,20 +2598,20 @@ impl<'a, C, NC, A> BookshelveMethods<'a, C, NC, A> { /// let rb = hub.promooffer(); /// # } /// ``` -pub struct PromoofferMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PromoofferMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, } -impl<'a, C, NC, A> MethodsBuilder for PromoofferMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PromoofferMethods<'a, C, A> {} -impl<'a, C, NC, A> PromoofferMethods<'a, C, NC, A> { +impl<'a, C, A> PromoofferMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// - pub fn accept(&self) -> PromoofferAcceptCall<'a, C, NC, A> { + pub fn accept(&self) -> PromoofferAcceptCall<'a, C, A> { PromoofferAcceptCall { hub: self.hub, _volume_id: Default::default(), @@ -2635,7 +2631,7 @@ impl<'a, C, NC, A> PromoofferMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// - pub fn dismiss(&self) -> PromoofferDismisCall<'a, C, NC, A> { + pub fn dismiss(&self) -> PromoofferDismisCall<'a, C, A> { PromoofferDismisCall { hub: self.hub, _serial: Default::default(), @@ -2654,7 +2650,7 @@ impl<'a, C, NC, A> PromoofferMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Returns a list of promo offers available to the user - pub fn get(&self) -> PromoofferGetCall<'a, C, NC, A> { + pub fn get(&self) -> PromoofferGetCall<'a, C, A> { PromoofferGetCall { hub: self.hub, _serial: Default::default(), @@ -2700,20 +2696,20 @@ impl<'a, C, NC, A> PromoofferMethods<'a, C, NC, A> { /// let rb = hub.onboarding(); /// # } /// ``` -pub struct OnboardingMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct OnboardingMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, } -impl<'a, C, NC, A> MethodsBuilder for OnboardingMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for OnboardingMethods<'a, C, A> {} -impl<'a, C, NC, A> OnboardingMethods<'a, C, NC, A> { +impl<'a, C, A> OnboardingMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// List categories for onboarding experience. - pub fn list_categories(&self) -> OnboardingListCategoryCall<'a, C, NC, A> { + pub fn list_categories(&self) -> OnboardingListCategoryCall<'a, C, A> { OnboardingListCategoryCall { hub: self.hub, _locale: Default::default(), @@ -2726,7 +2722,7 @@ impl<'a, C, NC, A> OnboardingMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// List available volumes under categories for onboarding experience. - pub fn list_category_volumes(&self) -> OnboardingListCategoryVolumeCall<'a, C, NC, A> { + pub fn list_category_volumes(&self) -> OnboardingListCategoryVolumeCall<'a, C, A> { OnboardingListCategoryVolumeCall { hub: self.hub, _page_token: Default::default(), @@ -2770,15 +2766,15 @@ impl<'a, C, NC, A> OnboardingMethods<'a, C, NC, A> { /// let rb = hub.myconfig(); /// # } /// ``` -pub struct MyconfigMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MyconfigMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, } -impl<'a, C, NC, A> MethodsBuilder for MyconfigMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for MyconfigMethods<'a, C, A> {} -impl<'a, C, NC, A> MyconfigMethods<'a, C, NC, A> { +impl<'a, C, A> MyconfigMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2790,7 +2786,7 @@ impl<'a, C, NC, A> MyconfigMethods<'a, C, NC, A> { /// * `volumeId` - The volume to request concurrent/download restrictions for. /// * `nonce` - The client nonce value. /// * `cpksver` - The device/version ID from which to request the restrictions. - pub fn request_access(&self, source: &str, volume_id: &str, nonce: &str, cpksver: &str) -> MyconfigRequestAccesCall<'a, C, NC, A> { + pub fn request_access(&self, source: &str, volume_id: &str, nonce: &str, cpksver: &str) -> MyconfigRequestAccesCall<'a, C, A> { MyconfigRequestAccesCall { hub: self.hub, _source: source.to_string(), @@ -2813,7 +2809,7 @@ impl<'a, C, NC, A> MyconfigMethods<'a, C, NC, A> { /// /// * `volumeIds` - The volume(s) to release restrictions for. /// * `cpksver` - The device/version ID from which to release the restriction. - pub fn release_download_access(&self, volume_ids: &Vec, cpksver: &str) -> MyconfigReleaseDownloadAccesCall<'a, C, NC, A> { + pub fn release_download_access(&self, volume_ids: &Vec, cpksver: &str) -> MyconfigReleaseDownloadAccesCall<'a, C, A> { MyconfigReleaseDownloadAccesCall { hub: self.hub, _volume_ids: volume_ids.clone(), @@ -2835,7 +2831,7 @@ impl<'a, C, NC, A> MyconfigMethods<'a, C, NC, A> { /// * `source` - String to identify the originator of this request. /// * `nonce` - The client nonce value. /// * `cpksver` - The device/version ID from which to release the restriction. - pub fn sync_volume_licenses(&self, source: &str, nonce: &str, cpksver: &str) -> MyconfigSyncVolumeLicenseCall<'a, C, NC, A> { + pub fn sync_volume_licenses(&self, source: &str, nonce: &str, cpksver: &str) -> MyconfigSyncVolumeLicenseCall<'a, C, A> { MyconfigSyncVolumeLicenseCall { hub: self.hub, _source: source.to_string(), @@ -2854,7 +2850,7 @@ impl<'a, C, NC, A> MyconfigMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Gets the current settings for the user. - pub fn get_user_settings(&self) -> MyconfigGetUserSettingCall<'a, C, NC, A> { + pub fn get_user_settings(&self) -> MyconfigGetUserSettingCall<'a, C, A> { MyconfigGetUserSettingCall { hub: self.hub, _delegate: Default::default(), @@ -2870,7 +2866,7 @@ impl<'a, C, NC, A> MyconfigMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn update_user_settings(&self, request: &Usersettings) -> MyconfigUpdateUserSettingCall<'a, C, NC, A> { + pub fn update_user_settings(&self, request: &Usersettings) -> MyconfigUpdateUserSettingCall<'a, C, A> { MyconfigUpdateUserSettingCall { hub: self.hub, _request: request.clone(), @@ -2911,15 +2907,15 @@ impl<'a, C, NC, A> MyconfigMethods<'a, C, NC, A> { /// let rb = hub.mylibrary(); /// # } /// ``` -pub struct MylibraryMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MylibraryMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, } -impl<'a, C, NC, A> MethodsBuilder for MylibraryMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for MylibraryMethods<'a, C, A> {} -impl<'a, C, NC, A> MylibraryMethods<'a, C, NC, A> { +impl<'a, C, A> MylibraryMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2928,7 +2924,7 @@ impl<'a, C, NC, A> MylibraryMethods<'a, C, NC, A> { /// # Arguments /// /// * `shelf` - ID of bookshelf from which to remove a volume. - pub fn bookshelves_clear_volumes(&self, shelf: &str) -> MylibraryBookshelveClearVolumeCall<'a, C, NC, A> { + pub fn bookshelves_clear_volumes(&self, shelf: &str) -> MylibraryBookshelveClearVolumeCall<'a, C, A> { MylibraryBookshelveClearVolumeCall { hub: self.hub, _shelf: shelf.to_string(), @@ -2948,7 +2944,7 @@ impl<'a, C, NC, A> MylibraryMethods<'a, C, NC, A> { /// * `shelf` - ID of bookshelf with the volume. /// * `volumeId` - ID of volume to move. /// * `volumePosition` - Position on shelf to move the item (0 puts the item before the current first item, 1 puts it between the first and the second and so on.) - pub fn bookshelves_move_volume(&self, shelf: &str, volume_id: &str, volume_position: i32) -> MylibraryBookshelveMoveVolumeCall<'a, C, NC, A> { + pub fn bookshelves_move_volume(&self, shelf: &str, volume_id: &str, volume_position: i32) -> MylibraryBookshelveMoveVolumeCall<'a, C, A> { MylibraryBookshelveMoveVolumeCall { hub: self.hub, _shelf: shelf.to_string(), @@ -2968,7 +2964,7 @@ impl<'a, C, NC, A> MylibraryMethods<'a, C, NC, A> { /// # Arguments /// /// * `shelf` - The bookshelf ID or name retrieve volumes for. - pub fn bookshelves_volumes_list(&self, shelf: &str) -> MylibraryBookshelveVolumeListCall<'a, C, NC, A> { + pub fn bookshelves_volumes_list(&self, shelf: &str) -> MylibraryBookshelveVolumeListCall<'a, C, A> { MylibraryBookshelveVolumeListCall { hub: self.hub, _shelf: shelf.to_string(), @@ -2993,7 +2989,7 @@ impl<'a, C, NC, A> MylibraryMethods<'a, C, NC, A> { /// /// * `layerIds` - Array of layer IDs to get the summary for. /// * `volumeId` - Volume id to get the summary for. - pub fn annotations_summary(&self, layer_ids: &Vec, volume_id: &str) -> MylibraryAnnotationSummaryCall<'a, C, NC, A> { + pub fn annotations_summary(&self, layer_ids: &Vec, volume_id: &str) -> MylibraryAnnotationSummaryCall<'a, C, A> { MylibraryAnnotationSummaryCall { hub: self.hub, _layer_ids: layer_ids.clone(), @@ -3011,7 +3007,7 @@ impl<'a, C, NC, A> MylibraryMethods<'a, C, NC, A> { /// # Arguments /// /// * `annotationId` - The ID for the annotation to delete. - pub fn annotations_delete(&self, annotation_id: &str) -> MylibraryAnnotationDeleteCall<'a, C, NC, A> { + pub fn annotations_delete(&self, annotation_id: &str) -> MylibraryAnnotationDeleteCall<'a, C, A> { MylibraryAnnotationDeleteCall { hub: self.hub, _annotation_id: annotation_id.to_string(), @@ -3030,7 +3026,7 @@ impl<'a, C, NC, A> MylibraryMethods<'a, C, NC, A> { /// /// * `shelf` - ID of bookshelf to which to add a volume. /// * `volumeId` - ID of volume to add. - pub fn bookshelves_add_volume(&self, shelf: &str, volume_id: &str) -> MylibraryBookshelveAddVolumeCall<'a, C, NC, A> { + pub fn bookshelves_add_volume(&self, shelf: &str, volume_id: &str) -> MylibraryBookshelveAddVolumeCall<'a, C, A> { MylibraryBookshelveAddVolumeCall { hub: self.hub, _shelf: shelf.to_string(), @@ -3050,7 +3046,7 @@ impl<'a, C, NC, A> MylibraryMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn annotations_insert(&self, request: &Annotation) -> MylibraryAnnotationInsertCall<'a, C, NC, A> { + pub fn annotations_insert(&self, request: &Annotation) -> MylibraryAnnotationInsertCall<'a, C, A> { MylibraryAnnotationInsertCall { hub: self.hub, _request: request.clone(), @@ -3071,7 +3067,7 @@ impl<'a, C, NC, A> MylibraryMethods<'a, C, NC, A> { /// /// * `shelf` - ID of bookshelf from which to remove a volume. /// * `volumeId` - ID of volume to remove. - pub fn bookshelves_remove_volume(&self, shelf: &str, volume_id: &str) -> MylibraryBookshelveRemoveVolumeCall<'a, C, NC, A> { + pub fn bookshelves_remove_volume(&self, shelf: &str, volume_id: &str) -> MylibraryBookshelveRemoveVolumeCall<'a, C, A> { MylibraryBookshelveRemoveVolumeCall { hub: self.hub, _shelf: shelf.to_string(), @@ -3087,7 +3083,7 @@ impl<'a, C, NC, A> MylibraryMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Retrieves a list of annotations, possibly filtered. - pub fn annotations_list(&self) -> MylibraryAnnotationListCall<'a, C, NC, A> { + pub fn annotations_list(&self) -> MylibraryAnnotationListCall<'a, C, A> { MylibraryAnnotationListCall { hub: self.hub, _volume_id: Default::default(), @@ -3114,7 +3110,7 @@ impl<'a, C, NC, A> MylibraryMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `annotationId` - The ID for the annotation to update. - pub fn annotations_update(&self, request: &Annotation, annotation_id: &str) -> MylibraryAnnotationUpdateCall<'a, C, NC, A> { + pub fn annotations_update(&self, request: &Annotation, annotation_id: &str) -> MylibraryAnnotationUpdateCall<'a, C, A> { MylibraryAnnotationUpdateCall { hub: self.hub, _request: request.clone(), @@ -3135,7 +3131,7 @@ impl<'a, C, NC, A> MylibraryMethods<'a, C, NC, A> { /// * `volumeId` - ID of volume for which to update the reading position. /// * `timestamp` - RFC 3339 UTC format timestamp associated with this reading position. /// * `position` - Position string for the new volume reading position. - pub fn readingpositions_set_position(&self, volume_id: &str, timestamp: &str, position: &str) -> MylibraryReadingpositionSetPositionCall<'a, C, NC, A> { + pub fn readingpositions_set_position(&self, volume_id: &str, timestamp: &str, position: &str) -> MylibraryReadingpositionSetPositionCall<'a, C, A> { MylibraryReadingpositionSetPositionCall { hub: self.hub, _volume_id: volume_id.to_string(), @@ -3158,7 +3154,7 @@ impl<'a, C, NC, A> MylibraryMethods<'a, C, NC, A> { /// # Arguments /// /// * `shelf` - ID of bookshelf to retrieve. - pub fn bookshelves_get(&self, shelf: &str) -> MylibraryBookshelveGetCall<'a, C, NC, A> { + pub fn bookshelves_get(&self, shelf: &str) -> MylibraryBookshelveGetCall<'a, C, A> { MylibraryBookshelveGetCall { hub: self.hub, _shelf: shelf.to_string(), @@ -3172,7 +3168,7 @@ impl<'a, C, NC, A> MylibraryMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Retrieves a list of bookshelves belonging to the authenticated user. - pub fn bookshelves_list(&self) -> MylibraryBookshelveListCall<'a, C, NC, A> { + pub fn bookshelves_list(&self) -> MylibraryBookshelveListCall<'a, C, A> { MylibraryBookshelveListCall { hub: self.hub, _source: Default::default(), @@ -3189,7 +3185,7 @@ impl<'a, C, NC, A> MylibraryMethods<'a, C, NC, A> { /// # Arguments /// /// * `volumeId` - ID of volume for which to retrieve a reading position. - pub fn readingpositions_get(&self, volume_id: &str) -> MylibraryReadingpositionGetCall<'a, C, NC, A> { + pub fn readingpositions_get(&self, volume_id: &str) -> MylibraryReadingpositionGetCall<'a, C, A> { MylibraryReadingpositionGetCall { hub: self.hub, _volume_id: volume_id.to_string(), @@ -3232,20 +3228,20 @@ impl<'a, C, NC, A> MylibraryMethods<'a, C, NC, A> { /// let rb = hub.cloudloading(); /// # } /// ``` -pub struct CloudloadingMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CloudloadingMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, } -impl<'a, C, NC, A> MethodsBuilder for CloudloadingMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CloudloadingMethods<'a, C, A> {} -impl<'a, C, NC, A> CloudloadingMethods<'a, C, NC, A> { +impl<'a, C, A> CloudloadingMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// - pub fn add_book(&self) -> CloudloadingAddBookCall<'a, C, NC, A> { + pub fn add_book(&self) -> CloudloadingAddBookCall<'a, C, A> { CloudloadingAddBookCall { hub: self.hub, _upload_client_token: Default::default(), @@ -3265,7 +3261,7 @@ impl<'a, C, NC, A> CloudloadingMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn update_book(&self, request: &BooksCloudloadingResource) -> CloudloadingUpdateBookCall<'a, C, NC, A> { + pub fn update_book(&self, request: &BooksCloudloadingResource) -> CloudloadingUpdateBookCall<'a, C, A> { CloudloadingUpdateBookCall { hub: self.hub, _request: request.clone(), @@ -3282,7 +3278,7 @@ impl<'a, C, NC, A> CloudloadingMethods<'a, C, NC, A> { /// # Arguments /// /// * `volumeId` - The id of the book to be removed. - pub fn delete_book(&self, volume_id: &str) -> CloudloadingDeleteBookCall<'a, C, NC, A> { + pub fn delete_book(&self, volume_id: &str) -> CloudloadingDeleteBookCall<'a, C, A> { CloudloadingDeleteBookCall { hub: self.hub, _volume_id: volume_id.to_string(), @@ -3337,10 +3333,10 @@ impl<'a, C, NC, A> CloudloadingMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct LayerAnnotationDataGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LayerAnnotationDataGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _volume_id: String, _layer_id: String, _annotation_data_id: String, @@ -3356,9 +3352,9 @@ pub struct LayerAnnotationDataGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LayerAnnotationDataGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LayerAnnotationDataGetCall<'a, C, A> {} -impl<'a, C, NC, A> LayerAnnotationDataGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LayerAnnotationDataGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3511,7 +3507,7 @@ impl<'a, C, NC, A> LayerAnnotationDataGetCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The volume to retrieve annotations for. - pub fn volume_id(mut self, new_value: &str) -> LayerAnnotationDataGetCall<'a, C, NC, A> { + pub fn volume_id(mut self, new_value: &str) -> LayerAnnotationDataGetCall<'a, C, A> { self._volume_id = new_value.to_string(); self } @@ -3521,7 +3517,7 @@ impl<'a, C, NC, A> LayerAnnotationDataGetCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The ID for the layer to get the annotations. - pub fn layer_id(mut self, new_value: &str) -> LayerAnnotationDataGetCall<'a, C, NC, A> { + pub fn layer_id(mut self, new_value: &str) -> LayerAnnotationDataGetCall<'a, C, A> { self._layer_id = new_value.to_string(); self } @@ -3531,7 +3527,7 @@ impl<'a, C, NC, A> LayerAnnotationDataGetCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The ID of the annotation data to retrieve. - pub fn annotation_data_id(mut self, new_value: &str) -> LayerAnnotationDataGetCall<'a, C, NC, A> { + pub fn annotation_data_id(mut self, new_value: &str) -> LayerAnnotationDataGetCall<'a, C, A> { self._annotation_data_id = new_value.to_string(); self } @@ -3541,7 +3537,7 @@ impl<'a, C, NC, A> LayerAnnotationDataGetCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The content version for the volume you are trying to retrieve. - pub fn content_version(mut self, new_value: &str) -> LayerAnnotationDataGetCall<'a, C, NC, A> { + pub fn content_version(mut self, new_value: &str) -> LayerAnnotationDataGetCall<'a, C, A> { self._content_version = new_value.to_string(); self } @@ -3549,7 +3545,7 @@ impl<'a, C, NC, A> LayerAnnotationDataGetCall<'a, C, NC, A> where NC: hyper::net /// /// /// The requested pixel width for any images. If width is provided height must also be provided. - pub fn w(mut self, new_value: i32) -> LayerAnnotationDataGetCall<'a, C, NC, A> { + pub fn w(mut self, new_value: i32) -> LayerAnnotationDataGetCall<'a, C, A> { self._w = Some(new_value); self } @@ -3557,7 +3553,7 @@ impl<'a, C, NC, A> LayerAnnotationDataGetCall<'a, C, NC, A> where NC: hyper::net /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> LayerAnnotationDataGetCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> LayerAnnotationDataGetCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -3565,7 +3561,7 @@ impl<'a, C, NC, A> LayerAnnotationDataGetCall<'a, C, NC, A> where NC: hyper::net /// /// /// The requested scale for the image. - pub fn scale(mut self, new_value: i32) -> LayerAnnotationDataGetCall<'a, C, NC, A> { + pub fn scale(mut self, new_value: i32) -> LayerAnnotationDataGetCall<'a, C, A> { self._scale = Some(new_value); self } @@ -3573,7 +3569,7 @@ impl<'a, C, NC, A> LayerAnnotationDataGetCall<'a, C, NC, A> where NC: hyper::net /// /// /// The locale information for the data. ISO-639-1 language and ISO-3166-1 country code. Ex: 'en_US'. - pub fn locale(mut self, new_value: &str) -> LayerAnnotationDataGetCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> LayerAnnotationDataGetCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -3581,7 +3577,7 @@ impl<'a, C, NC, A> LayerAnnotationDataGetCall<'a, C, NC, A> where NC: hyper::net /// /// /// The requested pixel height for any images. If height is provided width must also be provided. - pub fn h(mut self, new_value: i32) -> LayerAnnotationDataGetCall<'a, C, NC, A> { + pub fn h(mut self, new_value: i32) -> LayerAnnotationDataGetCall<'a, C, A> { self._h = Some(new_value); self } @@ -3589,7 +3585,7 @@ impl<'a, C, NC, A> LayerAnnotationDataGetCall<'a, C, NC, A> where NC: hyper::net /// /// /// For the dictionary layer. Whether or not to allow web definitions. - pub fn allow_web_definitions(mut self, new_value: bool) -> LayerAnnotationDataGetCall<'a, C, NC, A> { + pub fn allow_web_definitions(mut self, new_value: bool) -> LayerAnnotationDataGetCall<'a, C, A> { self._allow_web_definitions = Some(new_value); self } @@ -3600,7 +3596,7 @@ impl<'a, C, NC, A> LayerAnnotationDataGetCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerAnnotationDataGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerAnnotationDataGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3621,7 +3617,7 @@ impl<'a, C, NC, A> LayerAnnotationDataGetCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LayerAnnotationDataGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LayerAnnotationDataGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3638,7 +3634,7 @@ impl<'a, C, NC, A> LayerAnnotationDataGetCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LayerAnnotationDataGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LayerAnnotationDataGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3678,10 +3674,10 @@ impl<'a, C, NC, A> LayerAnnotationDataGetCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct LayerVolumeAnnotationGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LayerVolumeAnnotationGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _volume_id: String, _layer_id: String, _annotation_id: String, @@ -3692,9 +3688,9 @@ pub struct LayerVolumeAnnotationGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LayerVolumeAnnotationGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LayerVolumeAnnotationGetCall<'a, C, A> {} -impl<'a, C, NC, A> LayerVolumeAnnotationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LayerVolumeAnnotationGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3834,7 +3830,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationGetCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The volume to retrieve annotations for. - pub fn volume_id(mut self, new_value: &str) -> LayerVolumeAnnotationGetCall<'a, C, NC, A> { + pub fn volume_id(mut self, new_value: &str) -> LayerVolumeAnnotationGetCall<'a, C, A> { self._volume_id = new_value.to_string(); self } @@ -3844,7 +3840,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationGetCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The ID for the layer to get the annotations. - pub fn layer_id(mut self, new_value: &str) -> LayerVolumeAnnotationGetCall<'a, C, NC, A> { + pub fn layer_id(mut self, new_value: &str) -> LayerVolumeAnnotationGetCall<'a, C, A> { self._layer_id = new_value.to_string(); self } @@ -3854,7 +3850,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationGetCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The ID of the volume annotation to retrieve. - pub fn annotation_id(mut self, new_value: &str) -> LayerVolumeAnnotationGetCall<'a, C, NC, A> { + pub fn annotation_id(mut self, new_value: &str) -> LayerVolumeAnnotationGetCall<'a, C, A> { self._annotation_id = new_value.to_string(); self } @@ -3862,7 +3858,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationGetCall<'a, C, NC, A> where NC: hyper::n /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> LayerVolumeAnnotationGetCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> LayerVolumeAnnotationGetCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -3870,7 +3866,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationGetCall<'a, C, NC, A> where NC: hyper::n /// /// /// The locale information for the data. ISO-639-1 language and ISO-3166-1 country code. Ex: 'en_US'. - pub fn locale(mut self, new_value: &str) -> LayerVolumeAnnotationGetCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> LayerVolumeAnnotationGetCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -3881,7 +3877,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationGetCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerVolumeAnnotationGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerVolumeAnnotationGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3902,7 +3898,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationGetCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LayerVolumeAnnotationGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LayerVolumeAnnotationGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3919,7 +3915,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationGetCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LayerVolumeAnnotationGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LayerVolumeAnnotationGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3961,10 +3957,10 @@ impl<'a, C, NC, A> LayerVolumeAnnotationGetCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct LayerListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LayerListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _volume_id: String, _source: Option, _page_token: Option, @@ -3975,9 +3971,9 @@ pub struct LayerListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LayerListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LayerListCall<'a, C, A> {} -impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LayerListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4121,7 +4117,7 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The volume to retrieve layers for. - pub fn volume_id(mut self, new_value: &str) -> LayerListCall<'a, C, NC, A> { + pub fn volume_id(mut self, new_value: &str) -> LayerListCall<'a, C, A> { self._volume_id = new_value.to_string(); self } @@ -4129,7 +4125,7 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> LayerListCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> LayerListCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -4137,7 +4133,7 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The value of the nextToken from the previous page. - pub fn page_token(mut self, new_value: &str) -> LayerListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> LayerListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -4145,7 +4141,7 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Maximum number of results to return - pub fn max_results(mut self, new_value: u32) -> LayerListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> LayerListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -4153,7 +4149,7 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The content version for the requested volume. - pub fn content_version(mut self, new_value: &str) -> LayerListCall<'a, C, NC, A> { + pub fn content_version(mut self, new_value: &str) -> LayerListCall<'a, C, A> { self._content_version = Some(new_value.to_string()); self } @@ -4164,7 +4160,7 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4185,7 +4181,7 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LayerListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LayerListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4202,7 +4198,7 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LayerListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LayerListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4242,10 +4238,10 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct LayerGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LayerGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _volume_id: String, _summary_id: String, _source: Option, @@ -4255,9 +4251,9 @@ pub struct LayerGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LayerGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LayerGetCall<'a, C, A> {} -impl<'a, C, NC, A> LayerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LayerGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4396,7 +4392,7 @@ impl<'a, C, NC, A> LayerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The volume to retrieve layers for. - pub fn volume_id(mut self, new_value: &str) -> LayerGetCall<'a, C, NC, A> { + pub fn volume_id(mut self, new_value: &str) -> LayerGetCall<'a, C, A> { self._volume_id = new_value.to_string(); self } @@ -4406,7 +4402,7 @@ impl<'a, C, NC, A> LayerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The ID for the layer to get the summary for. - pub fn summary_id(mut self, new_value: &str) -> LayerGetCall<'a, C, NC, A> { + pub fn summary_id(mut self, new_value: &str) -> LayerGetCall<'a, C, A> { self._summary_id = new_value.to_string(); self } @@ -4414,7 +4410,7 @@ impl<'a, C, NC, A> LayerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> LayerGetCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> LayerGetCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -4422,7 +4418,7 @@ impl<'a, C, NC, A> LayerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The content version for the requested volume. - pub fn content_version(mut self, new_value: &str) -> LayerGetCall<'a, C, NC, A> { + pub fn content_version(mut self, new_value: &str) -> LayerGetCall<'a, C, A> { self._content_version = Some(new_value.to_string()); self } @@ -4433,7 +4429,7 @@ impl<'a, C, NC, A> LayerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4454,7 +4450,7 @@ impl<'a, C, NC, A> LayerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LayerGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LayerGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4471,7 +4467,7 @@ impl<'a, C, NC, A> LayerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LayerGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LayerGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4521,10 +4517,10 @@ impl<'a, C, NC, A> LayerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct LayerVolumeAnnotationListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LayerVolumeAnnotationListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _volume_id: String, _layer_id: String, _content_version: String, @@ -4545,9 +4541,9 @@ pub struct LayerVolumeAnnotationListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LayerVolumeAnnotationListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LayerVolumeAnnotationListCall<'a, C, A> {} -impl<'a, C, NC, A> LayerVolumeAnnotationListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LayerVolumeAnnotationListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4717,7 +4713,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationListCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The volume to retrieve annotations for. - pub fn volume_id(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, NC, A> { + pub fn volume_id(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, A> { self._volume_id = new_value.to_string(); self } @@ -4727,7 +4723,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationListCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The ID for the layer to get the annotations. - pub fn layer_id(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, NC, A> { + pub fn layer_id(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, A> { self._layer_id = new_value.to_string(); self } @@ -4737,7 +4733,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationListCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The content version for the requested volume. - pub fn content_version(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, NC, A> { + pub fn content_version(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, A> { self._content_version = new_value.to_string(); self } @@ -4745,7 +4741,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationListCall<'a, C, NC, A> where NC: hyper:: /// /// /// The version of the volume annotations that you are requesting. - pub fn volume_annotations_version(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, NC, A> { + pub fn volume_annotations_version(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, A> { self._volume_annotations_version = Some(new_value.to_string()); self } @@ -4753,7 +4749,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationListCall<'a, C, NC, A> where NC: hyper:: /// /// /// RFC 3339 timestamp to restrict to items updated since this timestamp (inclusive). - pub fn updated_min(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, NC, A> { + pub fn updated_min(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, A> { self._updated_min = Some(new_value.to_string()); self } @@ -4761,7 +4757,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationListCall<'a, C, NC, A> where NC: hyper:: /// /// /// RFC 3339 timestamp to restrict to items updated prior to this timestamp (exclusive). - pub fn updated_max(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, NC, A> { + pub fn updated_max(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, A> { self._updated_max = Some(new_value.to_string()); self } @@ -4769,7 +4765,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationListCall<'a, C, NC, A> where NC: hyper:: /// /// /// The start position to start retrieving data from. - pub fn start_position(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, NC, A> { + pub fn start_position(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, A> { self._start_position = Some(new_value.to_string()); self } @@ -4777,7 +4773,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationListCall<'a, C, NC, A> where NC: hyper:: /// /// /// The start offset to start retrieving data from. - pub fn start_offset(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, NC, A> { + pub fn start_offset(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, A> { self._start_offset = Some(new_value.to_string()); self } @@ -4785,7 +4781,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationListCall<'a, C, NC, A> where NC: hyper:: /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -4793,7 +4789,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationListCall<'a, C, NC, A> where NC: hyper:: /// /// /// Set to true to return deleted annotations. updatedMin must be in the request to use this. Defaults to false. - pub fn show_deleted(mut self, new_value: bool) -> LayerVolumeAnnotationListCall<'a, C, NC, A> { + pub fn show_deleted(mut self, new_value: bool) -> LayerVolumeAnnotationListCall<'a, C, A> { self._show_deleted = Some(new_value); self } @@ -4801,7 +4797,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationListCall<'a, C, NC, A> where NC: hyper:: /// /// /// The value of the nextToken from the previous page. - pub fn page_token(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -4809,7 +4805,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationListCall<'a, C, NC, A> where NC: hyper:: /// /// /// Maximum number of results to return - pub fn max_results(mut self, new_value: u32) -> LayerVolumeAnnotationListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> LayerVolumeAnnotationListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -4817,7 +4813,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationListCall<'a, C, NC, A> where NC: hyper:: /// /// /// The locale information for the data. ISO-639-1 language and ISO-3166-1 country code. Ex: 'en_US'. - pub fn locale(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -4825,7 +4821,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationListCall<'a, C, NC, A> where NC: hyper:: /// /// /// The end position to end retrieving data from. - pub fn end_position(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, NC, A> { + pub fn end_position(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, A> { self._end_position = Some(new_value.to_string()); self } @@ -4833,7 +4829,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationListCall<'a, C, NC, A> where NC: hyper:: /// /// /// The end offset to end retrieving data from. - pub fn end_offset(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, NC, A> { + pub fn end_offset(mut self, new_value: &str) -> LayerVolumeAnnotationListCall<'a, C, A> { self._end_offset = Some(new_value.to_string()); self } @@ -4844,7 +4840,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationListCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerVolumeAnnotationListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerVolumeAnnotationListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4865,7 +4861,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationListCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LayerVolumeAnnotationListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LayerVolumeAnnotationListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4882,7 +4878,7 @@ impl<'a, C, NC, A> LayerVolumeAnnotationListCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LayerVolumeAnnotationListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LayerVolumeAnnotationListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4930,10 +4926,10 @@ impl<'a, C, NC, A> LayerVolumeAnnotationListCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct LayerAnnotationDataListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LayerAnnotationDataListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _volume_id: String, _layer_id: String, _content_version: String, @@ -4952,9 +4948,9 @@ pub struct LayerAnnotationDataListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LayerAnnotationDataListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LayerAnnotationDataListCall<'a, C, A> {} -impl<'a, C, NC, A> LayerAnnotationDataListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LayerAnnotationDataListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5122,7 +5118,7 @@ impl<'a, C, NC, A> LayerAnnotationDataListCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The volume to retrieve annotation data for. - pub fn volume_id(mut self, new_value: &str) -> LayerAnnotationDataListCall<'a, C, NC, A> { + pub fn volume_id(mut self, new_value: &str) -> LayerAnnotationDataListCall<'a, C, A> { self._volume_id = new_value.to_string(); self } @@ -5132,7 +5128,7 @@ impl<'a, C, NC, A> LayerAnnotationDataListCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The ID for the layer to get the annotation data. - pub fn layer_id(mut self, new_value: &str) -> LayerAnnotationDataListCall<'a, C, NC, A> { + pub fn layer_id(mut self, new_value: &str) -> LayerAnnotationDataListCall<'a, C, A> { self._layer_id = new_value.to_string(); self } @@ -5142,7 +5138,7 @@ impl<'a, C, NC, A> LayerAnnotationDataListCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The content version for the requested volume. - pub fn content_version(mut self, new_value: &str) -> LayerAnnotationDataListCall<'a, C, NC, A> { + pub fn content_version(mut self, new_value: &str) -> LayerAnnotationDataListCall<'a, C, A> { self._content_version = new_value.to_string(); self } @@ -5150,7 +5146,7 @@ impl<'a, C, NC, A> LayerAnnotationDataListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// The requested pixel width for any images. If width is provided height must also be provided. - pub fn w(mut self, new_value: i32) -> LayerAnnotationDataListCall<'a, C, NC, A> { + pub fn w(mut self, new_value: i32) -> LayerAnnotationDataListCall<'a, C, A> { self._w = Some(new_value); self } @@ -5158,7 +5154,7 @@ impl<'a, C, NC, A> LayerAnnotationDataListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// RFC 3339 timestamp to restrict to items updated since this timestamp (inclusive). - pub fn updated_min(mut self, new_value: &str) -> LayerAnnotationDataListCall<'a, C, NC, A> { + pub fn updated_min(mut self, new_value: &str) -> LayerAnnotationDataListCall<'a, C, A> { self._updated_min = Some(new_value.to_string()); self } @@ -5166,7 +5162,7 @@ impl<'a, C, NC, A> LayerAnnotationDataListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// RFC 3339 timestamp to restrict to items updated prior to this timestamp (exclusive). - pub fn updated_max(mut self, new_value: &str) -> LayerAnnotationDataListCall<'a, C, NC, A> { + pub fn updated_max(mut self, new_value: &str) -> LayerAnnotationDataListCall<'a, C, A> { self._updated_max = Some(new_value.to_string()); self } @@ -5174,7 +5170,7 @@ impl<'a, C, NC, A> LayerAnnotationDataListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> LayerAnnotationDataListCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> LayerAnnotationDataListCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -5182,7 +5178,7 @@ impl<'a, C, NC, A> LayerAnnotationDataListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// The requested scale for the image. - pub fn scale(mut self, new_value: i32) -> LayerAnnotationDataListCall<'a, C, NC, A> { + pub fn scale(mut self, new_value: i32) -> LayerAnnotationDataListCall<'a, C, A> { self._scale = Some(new_value); self } @@ -5190,7 +5186,7 @@ impl<'a, C, NC, A> LayerAnnotationDataListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// The value of the nextToken from the previous page. - pub fn page_token(mut self, new_value: &str) -> LayerAnnotationDataListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> LayerAnnotationDataListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -5198,7 +5194,7 @@ impl<'a, C, NC, A> LayerAnnotationDataListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// Maximum number of results to return - pub fn max_results(mut self, new_value: u32) -> LayerAnnotationDataListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> LayerAnnotationDataListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -5206,7 +5202,7 @@ impl<'a, C, NC, A> LayerAnnotationDataListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// The locale information for the data. ISO-639-1 language and ISO-3166-1 country code. Ex: 'en_US'. - pub fn locale(mut self, new_value: &str) -> LayerAnnotationDataListCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> LayerAnnotationDataListCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -5214,7 +5210,7 @@ impl<'a, C, NC, A> LayerAnnotationDataListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// The requested pixel height for any images. If height is provided width must also be provided. - pub fn h(mut self, new_value: i32) -> LayerAnnotationDataListCall<'a, C, NC, A> { + pub fn h(mut self, new_value: i32) -> LayerAnnotationDataListCall<'a, C, A> { self._h = Some(new_value); self } @@ -5223,7 +5219,7 @@ impl<'a, C, NC, A> LayerAnnotationDataListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// The list of Annotation Data Ids to retrieve. Pagination is ignored if this is set. - pub fn add_annotation_data_id(mut self, new_value: &str) -> LayerAnnotationDataListCall<'a, C, NC, A> { + pub fn add_annotation_data_id(mut self, new_value: &str) -> LayerAnnotationDataListCall<'a, C, A> { self._annotation_data_id.push(new_value.to_string()); self } @@ -5234,7 +5230,7 @@ impl<'a, C, NC, A> LayerAnnotationDataListCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerAnnotationDataListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerAnnotationDataListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5255,7 +5251,7 @@ impl<'a, C, NC, A> LayerAnnotationDataListCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LayerAnnotationDataListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LayerAnnotationDataListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5272,7 +5268,7 @@ impl<'a, C, NC, A> LayerAnnotationDataListCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LayerAnnotationDataListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LayerAnnotationDataListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5312,10 +5308,10 @@ impl<'a, C, NC, A> LayerAnnotationDataListCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct VolumeRecommendedRateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VolumeRecommendedRateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _rating: String, _volume_id: String, _source: Option, @@ -5325,9 +5321,9 @@ pub struct VolumeRecommendedRateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VolumeRecommendedRateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VolumeRecommendedRateCall<'a, C, A> {} -impl<'a, C, NC, A> VolumeRecommendedRateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VolumeRecommendedRateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5442,7 +5438,7 @@ impl<'a, C, NC, A> VolumeRecommendedRateCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Rating to be given to the volume. - pub fn rating(mut self, new_value: &str) -> VolumeRecommendedRateCall<'a, C, NC, A> { + pub fn rating(mut self, new_value: &str) -> VolumeRecommendedRateCall<'a, C, A> { self._rating = new_value.to_string(); self } @@ -5452,7 +5448,7 @@ impl<'a, C, NC, A> VolumeRecommendedRateCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// ID of the source volume. - pub fn volume_id(mut self, new_value: &str) -> VolumeRecommendedRateCall<'a, C, NC, A> { + pub fn volume_id(mut self, new_value: &str) -> VolumeRecommendedRateCall<'a, C, A> { self._volume_id = new_value.to_string(); self } @@ -5460,7 +5456,7 @@ impl<'a, C, NC, A> VolumeRecommendedRateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> VolumeRecommendedRateCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> VolumeRecommendedRateCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -5468,7 +5464,7 @@ impl<'a, C, NC, A> VolumeRecommendedRateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// ISO-639-1 language and ISO-3166-1 country code. Ex: 'en_US'. Used for generating recommendations. - pub fn locale(mut self, new_value: &str) -> VolumeRecommendedRateCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> VolumeRecommendedRateCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -5479,7 +5475,7 @@ impl<'a, C, NC, A> VolumeRecommendedRateCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VolumeRecommendedRateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VolumeRecommendedRateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5500,7 +5496,7 @@ impl<'a, C, NC, A> VolumeRecommendedRateCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VolumeRecommendedRateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VolumeRecommendedRateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5517,7 +5513,7 @@ impl<'a, C, NC, A> VolumeRecommendedRateCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VolumeRecommendedRateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VolumeRecommendedRateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5561,10 +5557,10 @@ impl<'a, C, NC, A> VolumeRecommendedRateCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct VolumeMybookListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VolumeMybookListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _start_index: Option, _source: Option, _processing_state: Vec, @@ -5576,9 +5572,9 @@ pub struct VolumeMybookListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VolumeMybookListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VolumeMybookListCall<'a, C, A> {} -impl<'a, C, NC, A> VolumeMybookListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VolumeMybookListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5709,7 +5705,7 @@ impl<'a, C, NC, A> VolumeMybookListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Index of the first result to return (starts at 0) - pub fn start_index(mut self, new_value: u32) -> VolumeMybookListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: u32) -> VolumeMybookListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -5717,7 +5713,7 @@ impl<'a, C, NC, A> VolumeMybookListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> VolumeMybookListCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> VolumeMybookListCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -5726,7 +5722,7 @@ impl<'a, C, NC, A> VolumeMybookListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The processing state of the user uploaded volumes to be returned. Applicable only if the UPLOADED is specified in the acquireMethod. - pub fn add_processing_state(mut self, new_value: &str) -> VolumeMybookListCall<'a, C, NC, A> { + pub fn add_processing_state(mut self, new_value: &str) -> VolumeMybookListCall<'a, C, A> { self._processing_state.push(new_value.to_string()); self } @@ -5734,7 +5730,7 @@ impl<'a, C, NC, A> VolumeMybookListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: u32) -> VolumeMybookListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> VolumeMybookListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -5742,7 +5738,7 @@ impl<'a, C, NC, A> VolumeMybookListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// ISO-639-1 language and ISO-3166-1 country code. Ex:'en_US'. Used for generating recommendations. - pub fn locale(mut self, new_value: &str) -> VolumeMybookListCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> VolumeMybookListCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -5751,7 +5747,7 @@ impl<'a, C, NC, A> VolumeMybookListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// How the book was aquired - pub fn add_acquire_method(mut self, new_value: &str) -> VolumeMybookListCall<'a, C, NC, A> { + pub fn add_acquire_method(mut self, new_value: &str) -> VolumeMybookListCall<'a, C, A> { self._acquire_method.push(new_value.to_string()); self } @@ -5762,7 +5758,7 @@ impl<'a, C, NC, A> VolumeMybookListCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VolumeMybookListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VolumeMybookListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5783,7 +5779,7 @@ impl<'a, C, NC, A> VolumeMybookListCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VolumeMybookListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VolumeMybookListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5800,7 +5796,7 @@ impl<'a, C, NC, A> VolumeMybookListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VolumeMybookListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VolumeMybookListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5850,10 +5846,10 @@ impl<'a, C, NC, A> VolumeMybookListCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct VolumeListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VolumeListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _q: String, _start_index: Option, _source: Option, @@ -5872,9 +5868,9 @@ pub struct VolumeListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VolumeListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VolumeListCall<'a, C, A> {} -impl<'a, C, NC, A> VolumeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VolumeListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6018,7 +6014,7 @@ impl<'a, C, NC, A> VolumeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Full-text search query string. - pub fn q(mut self, new_value: &str) -> VolumeListCall<'a, C, NC, A> { + pub fn q(mut self, new_value: &str) -> VolumeListCall<'a, C, A> { self._q = new_value.to_string(); self } @@ -6026,7 +6022,7 @@ impl<'a, C, NC, A> VolumeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Index of the first result to return (starts at 0) - pub fn start_index(mut self, new_value: u32) -> VolumeListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: u32) -> VolumeListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -6034,7 +6030,7 @@ impl<'a, C, NC, A> VolumeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> VolumeListCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> VolumeListCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -6042,7 +6038,7 @@ impl<'a, C, NC, A> VolumeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Set to true to show books available for preorder. Defaults to false. - pub fn show_preorders(mut self, new_value: bool) -> VolumeListCall<'a, C, NC, A> { + pub fn show_preorders(mut self, new_value: bool) -> VolumeListCall<'a, C, A> { self._show_preorders = Some(new_value); self } @@ -6050,7 +6046,7 @@ impl<'a, C, NC, A> VolumeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Restrict information returned to a set of selected fields. - pub fn projection(mut self, new_value: &str) -> VolumeListCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> VolumeListCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -6058,7 +6054,7 @@ impl<'a, C, NC, A> VolumeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Restrict to books or magazines. - pub fn print_type(mut self, new_value: &str) -> VolumeListCall<'a, C, NC, A> { + pub fn print_type(mut self, new_value: &str) -> VolumeListCall<'a, C, A> { self._print_type = Some(new_value.to_string()); self } @@ -6066,7 +6062,7 @@ impl<'a, C, NC, A> VolumeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Restrict and brand results for partner ID. - pub fn partner(mut self, new_value: &str) -> VolumeListCall<'a, C, NC, A> { + pub fn partner(mut self, new_value: &str) -> VolumeListCall<'a, C, A> { self._partner = Some(new_value.to_string()); self } @@ -6074,7 +6070,7 @@ impl<'a, C, NC, A> VolumeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Sort search results. - pub fn order_by(mut self, new_value: &str) -> VolumeListCall<'a, C, NC, A> { + pub fn order_by(mut self, new_value: &str) -> VolumeListCall<'a, C, A> { self._order_by = Some(new_value.to_string()); self } @@ -6082,7 +6078,7 @@ impl<'a, C, NC, A> VolumeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: u32) -> VolumeListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> VolumeListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -6090,7 +6086,7 @@ impl<'a, C, NC, A> VolumeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Restrict search to this user's library. - pub fn library_restrict(mut self, new_value: &str) -> VolumeListCall<'a, C, NC, A> { + pub fn library_restrict(mut self, new_value: &str) -> VolumeListCall<'a, C, A> { self._library_restrict = Some(new_value.to_string()); self } @@ -6098,7 +6094,7 @@ impl<'a, C, NC, A> VolumeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Restrict results to books with this language code. - pub fn lang_restrict(mut self, new_value: &str) -> VolumeListCall<'a, C, NC, A> { + pub fn lang_restrict(mut self, new_value: &str) -> VolumeListCall<'a, C, A> { self._lang_restrict = Some(new_value.to_string()); self } @@ -6106,7 +6102,7 @@ impl<'a, C, NC, A> VolumeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Filter search results. - pub fn filter(mut self, new_value: &str) -> VolumeListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> VolumeListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -6114,7 +6110,7 @@ impl<'a, C, NC, A> VolumeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Restrict to volumes by download availability. - pub fn download(mut self, new_value: &str) -> VolumeListCall<'a, C, NC, A> { + pub fn download(mut self, new_value: &str) -> VolumeListCall<'a, C, A> { self._download = Some(new_value.to_string()); self } @@ -6125,7 +6121,7 @@ impl<'a, C, NC, A> VolumeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VolumeListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VolumeListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6146,7 +6142,7 @@ impl<'a, C, NC, A> VolumeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VolumeListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VolumeListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6163,7 +6159,7 @@ impl<'a, C, NC, A> VolumeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VolumeListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VolumeListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6207,10 +6203,10 @@ impl<'a, C, NC, A> VolumeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct VolumeUseruploadedListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VolumeUseruploadedListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _volume_id: Vec, _start_index: Option, _source: Option, @@ -6222,9 +6218,9 @@ pub struct VolumeUseruploadedListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VolumeUseruploadedListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VolumeUseruploadedListCall<'a, C, A> {} -impl<'a, C, NC, A> VolumeUseruploadedListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VolumeUseruploadedListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6356,7 +6352,7 @@ impl<'a, C, NC, A> VolumeUseruploadedListCall<'a, C, NC, A> where NC: hyper::net /// /// /// The ids of the volumes to be returned. If not specified all that match the processingState are returned. - pub fn add_volume_id(mut self, new_value: &str) -> VolumeUseruploadedListCall<'a, C, NC, A> { + pub fn add_volume_id(mut self, new_value: &str) -> VolumeUseruploadedListCall<'a, C, A> { self._volume_id.push(new_value.to_string()); self } @@ -6364,7 +6360,7 @@ impl<'a, C, NC, A> VolumeUseruploadedListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Index of the first result to return (starts at 0) - pub fn start_index(mut self, new_value: u32) -> VolumeUseruploadedListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: u32) -> VolumeUseruploadedListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -6372,7 +6368,7 @@ impl<'a, C, NC, A> VolumeUseruploadedListCall<'a, C, NC, A> where NC: hyper::net /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> VolumeUseruploadedListCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> VolumeUseruploadedListCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -6381,7 +6377,7 @@ impl<'a, C, NC, A> VolumeUseruploadedListCall<'a, C, NC, A> where NC: hyper::net /// /// /// The processing state of the user uploaded volumes to be returned. - pub fn add_processing_state(mut self, new_value: &str) -> VolumeUseruploadedListCall<'a, C, NC, A> { + pub fn add_processing_state(mut self, new_value: &str) -> VolumeUseruploadedListCall<'a, C, A> { self._processing_state.push(new_value.to_string()); self } @@ -6389,7 +6385,7 @@ impl<'a, C, NC, A> VolumeUseruploadedListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: u32) -> VolumeUseruploadedListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> VolumeUseruploadedListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -6397,7 +6393,7 @@ impl<'a, C, NC, A> VolumeUseruploadedListCall<'a, C, NC, A> where NC: hyper::net /// /// /// ISO-639-1 language and ISO-3166-1 country code. Ex: 'en_US'. Used for generating recommendations. - pub fn locale(mut self, new_value: &str) -> VolumeUseruploadedListCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> VolumeUseruploadedListCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -6408,7 +6404,7 @@ impl<'a, C, NC, A> VolumeUseruploadedListCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VolumeUseruploadedListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VolumeUseruploadedListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6429,7 +6425,7 @@ impl<'a, C, NC, A> VolumeUseruploadedListCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VolumeUseruploadedListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VolumeUseruploadedListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6446,7 +6442,7 @@ impl<'a, C, NC, A> VolumeUseruploadedListCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VolumeUseruploadedListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VolumeUseruploadedListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6487,10 +6483,10 @@ impl<'a, C, NC, A> VolumeUseruploadedListCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct VolumeAssociatedListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VolumeAssociatedListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _volume_id: String, _source: Option, _locale: Option, @@ -6500,9 +6496,9 @@ pub struct VolumeAssociatedListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VolumeAssociatedListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VolumeAssociatedListCall<'a, C, A> {} -impl<'a, C, NC, A> VolumeAssociatedListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VolumeAssociatedListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6643,7 +6639,7 @@ impl<'a, C, NC, A> VolumeAssociatedListCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// ID of the source volume. - pub fn volume_id(mut self, new_value: &str) -> VolumeAssociatedListCall<'a, C, NC, A> { + pub fn volume_id(mut self, new_value: &str) -> VolumeAssociatedListCall<'a, C, A> { self._volume_id = new_value.to_string(); self } @@ -6651,7 +6647,7 @@ impl<'a, C, NC, A> VolumeAssociatedListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> VolumeAssociatedListCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> VolumeAssociatedListCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -6659,7 +6655,7 @@ impl<'a, C, NC, A> VolumeAssociatedListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// ISO-639-1 language and ISO-3166-1 country code. Ex: 'en_US'. Used for generating recommendations. - pub fn locale(mut self, new_value: &str) -> VolumeAssociatedListCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> VolumeAssociatedListCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -6667,7 +6663,7 @@ impl<'a, C, NC, A> VolumeAssociatedListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// Association type. - pub fn association(mut self, new_value: &str) -> VolumeAssociatedListCall<'a, C, NC, A> { + pub fn association(mut self, new_value: &str) -> VolumeAssociatedListCall<'a, C, A> { self._association = Some(new_value.to_string()); self } @@ -6678,7 +6674,7 @@ impl<'a, C, NC, A> VolumeAssociatedListCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VolumeAssociatedListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VolumeAssociatedListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6699,7 +6695,7 @@ impl<'a, C, NC, A> VolumeAssociatedListCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VolumeAssociatedListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VolumeAssociatedListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6716,7 +6712,7 @@ impl<'a, C, NC, A> VolumeAssociatedListCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VolumeAssociatedListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VolumeAssociatedListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6759,10 +6755,10 @@ impl<'a, C, NC, A> VolumeAssociatedListCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct VolumeGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VolumeGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _volume_id: String, _user_library_consistent_read: Option, _source: Option, @@ -6774,9 +6770,9 @@ pub struct VolumeGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VolumeGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VolumeGetCall<'a, C, A> {} -impl<'a, C, NC, A> VolumeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VolumeGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6923,14 +6919,14 @@ impl<'a, C, NC, A> VolumeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// ID of volume to retrieve. - pub fn volume_id(mut self, new_value: &str) -> VolumeGetCall<'a, C, NC, A> { + pub fn volume_id(mut self, new_value: &str) -> VolumeGetCall<'a, C, A> { self._volume_id = new_value.to_string(); self } /// Sets the *user_library_consistent_read* query property to the given value. /// /// - pub fn user_library_consistent_read(mut self, new_value: bool) -> VolumeGetCall<'a, C, NC, A> { + pub fn user_library_consistent_read(mut self, new_value: bool) -> VolumeGetCall<'a, C, A> { self._user_library_consistent_read = Some(new_value); self } @@ -6938,7 +6934,7 @@ impl<'a, C, NC, A> VolumeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> VolumeGetCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> VolumeGetCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -6946,7 +6942,7 @@ impl<'a, C, NC, A> VolumeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Restrict information returned to a set of selected fields. - pub fn projection(mut self, new_value: &str) -> VolumeGetCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> VolumeGetCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -6954,7 +6950,7 @@ impl<'a, C, NC, A> VolumeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Brand results for partner ID. - pub fn partner(mut self, new_value: &str) -> VolumeGetCall<'a, C, NC, A> { + pub fn partner(mut self, new_value: &str) -> VolumeGetCall<'a, C, A> { self._partner = Some(new_value.to_string()); self } @@ -6962,7 +6958,7 @@ impl<'a, C, NC, A> VolumeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// ISO-3166-1 code to override the IP-based location. - pub fn country(mut self, new_value: &str) -> VolumeGetCall<'a, C, NC, A> { + pub fn country(mut self, new_value: &str) -> VolumeGetCall<'a, C, A> { self._country = Some(new_value.to_string()); self } @@ -6973,7 +6969,7 @@ impl<'a, C, NC, A> VolumeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VolumeGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VolumeGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6994,7 +6990,7 @@ impl<'a, C, NC, A> VolumeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VolumeGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VolumeGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7011,7 +7007,7 @@ impl<'a, C, NC, A> VolumeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VolumeGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VolumeGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7051,10 +7047,10 @@ impl<'a, C, NC, A> VolumeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct VolumeRecommendedListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VolumeRecommendedListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _source: Option, _locale: Option, _delegate: Option<&'a mut Delegate>, @@ -7062,9 +7058,9 @@ pub struct VolumeRecommendedListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VolumeRecommendedListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VolumeRecommendedListCall<'a, C, A> {} -impl<'a, C, NC, A> VolumeRecommendedListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VolumeRecommendedListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7175,7 +7171,7 @@ impl<'a, C, NC, A> VolumeRecommendedListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> VolumeRecommendedListCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> VolumeRecommendedListCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -7183,7 +7179,7 @@ impl<'a, C, NC, A> VolumeRecommendedListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// ISO-639-1 language and ISO-3166-1 country code. Ex: 'en_US'. Used for generating recommendations. - pub fn locale(mut self, new_value: &str) -> VolumeRecommendedListCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> VolumeRecommendedListCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -7194,7 +7190,7 @@ impl<'a, C, NC, A> VolumeRecommendedListCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VolumeRecommendedListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VolumeRecommendedListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7215,7 +7211,7 @@ impl<'a, C, NC, A> VolumeRecommendedListCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VolumeRecommendedListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VolumeRecommendedListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7232,7 +7228,7 @@ impl<'a, C, NC, A> VolumeRecommendedListCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VolumeRecommendedListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VolumeRecommendedListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7270,19 +7266,19 @@ impl<'a, C, NC, A> VolumeRecommendedListCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct DictionaryListOfflineMetadataCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DictionaryListOfflineMetadataCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _cpksver: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DictionaryListOfflineMetadataCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DictionaryListOfflineMetadataCall<'a, C, A> {} -impl<'a, C, NC, A> DictionaryListOfflineMetadataCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DictionaryListOfflineMetadataCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7390,7 +7386,7 @@ impl<'a, C, NC, A> DictionaryListOfflineMetadataCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// The device/version ID from which to request the data. - pub fn cpksver(mut self, new_value: &str) -> DictionaryListOfflineMetadataCall<'a, C, NC, A> { + pub fn cpksver(mut self, new_value: &str) -> DictionaryListOfflineMetadataCall<'a, C, A> { self._cpksver = new_value.to_string(); self } @@ -7401,7 +7397,7 @@ impl<'a, C, NC, A> DictionaryListOfflineMetadataCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DictionaryListOfflineMetadataCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DictionaryListOfflineMetadataCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7422,7 +7418,7 @@ impl<'a, C, NC, A> DictionaryListOfflineMetadataCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DictionaryListOfflineMetadataCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DictionaryListOfflineMetadataCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7439,7 +7435,7 @@ impl<'a, C, NC, A> DictionaryListOfflineMetadataCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DictionaryListOfflineMetadataCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DictionaryListOfflineMetadataCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7481,10 +7477,10 @@ impl<'a, C, NC, A> DictionaryListOfflineMetadataCall<'a, C, NC, A> where NC: hyp /// .doit(); /// # } /// ``` -pub struct BookshelveVolumeListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BookshelveVolumeListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _user_id: String, _shelf: String, _start_index: Option, @@ -7496,9 +7492,9 @@ pub struct BookshelveVolumeListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BookshelveVolumeListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BookshelveVolumeListCall<'a, C, A> {} -impl<'a, C, NC, A> BookshelveVolumeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BookshelveVolumeListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7643,7 +7639,7 @@ impl<'a, C, NC, A> BookshelveVolumeListCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// ID of user for whom to retrieve bookshelf volumes. - pub fn user_id(mut self, new_value: &str) -> BookshelveVolumeListCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> BookshelveVolumeListCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -7653,7 +7649,7 @@ impl<'a, C, NC, A> BookshelveVolumeListCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// ID of bookshelf to retrieve volumes. - pub fn shelf(mut self, new_value: &str) -> BookshelveVolumeListCall<'a, C, NC, A> { + pub fn shelf(mut self, new_value: &str) -> BookshelveVolumeListCall<'a, C, A> { self._shelf = new_value.to_string(); self } @@ -7661,7 +7657,7 @@ impl<'a, C, NC, A> BookshelveVolumeListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// Index of the first element to return (starts at 0) - pub fn start_index(mut self, new_value: u32) -> BookshelveVolumeListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: u32) -> BookshelveVolumeListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -7669,7 +7665,7 @@ impl<'a, C, NC, A> BookshelveVolumeListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> BookshelveVolumeListCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> BookshelveVolumeListCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -7677,7 +7673,7 @@ impl<'a, C, NC, A> BookshelveVolumeListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// Set to true to show pre-ordered books. Defaults to false. - pub fn show_preorders(mut self, new_value: bool) -> BookshelveVolumeListCall<'a, C, NC, A> { + pub fn show_preorders(mut self, new_value: bool) -> BookshelveVolumeListCall<'a, C, A> { self._show_preorders = Some(new_value); self } @@ -7685,7 +7681,7 @@ impl<'a, C, NC, A> BookshelveVolumeListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// Maximum number of results to return - pub fn max_results(mut self, new_value: u32) -> BookshelveVolumeListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> BookshelveVolumeListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -7696,7 +7692,7 @@ impl<'a, C, NC, A> BookshelveVolumeListCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BookshelveVolumeListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BookshelveVolumeListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7717,7 +7713,7 @@ impl<'a, C, NC, A> BookshelveVolumeListCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BookshelveVolumeListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BookshelveVolumeListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7734,7 +7730,7 @@ impl<'a, C, NC, A> BookshelveVolumeListCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BookshelveVolumeListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BookshelveVolumeListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7773,10 +7769,10 @@ impl<'a, C, NC, A> BookshelveVolumeListCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct BookshelveListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BookshelveListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _user_id: String, _source: Option, _delegate: Option<&'a mut Delegate>, @@ -7784,9 +7780,9 @@ pub struct BookshelveListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BookshelveListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BookshelveListCall<'a, C, A> {} -impl<'a, C, NC, A> BookshelveListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BookshelveListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7921,7 +7917,7 @@ impl<'a, C, NC, A> BookshelveListCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// ID of user for whom to retrieve bookshelves. - pub fn user_id(mut self, new_value: &str) -> BookshelveListCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> BookshelveListCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -7929,7 +7925,7 @@ impl<'a, C, NC, A> BookshelveListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> BookshelveListCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> BookshelveListCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -7940,7 +7936,7 @@ impl<'a, C, NC, A> BookshelveListCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BookshelveListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BookshelveListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7961,7 +7957,7 @@ impl<'a, C, NC, A> BookshelveListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BookshelveListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BookshelveListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7978,7 +7974,7 @@ impl<'a, C, NC, A> BookshelveListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BookshelveListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BookshelveListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8017,10 +8013,10 @@ impl<'a, C, NC, A> BookshelveListCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct BookshelveGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BookshelveGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _user_id: String, _shelf: String, _source: Option, @@ -8029,9 +8025,9 @@ pub struct BookshelveGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BookshelveGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BookshelveGetCall<'a, C, A> {} -impl<'a, C, NC, A> BookshelveGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BookshelveGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8167,7 +8163,7 @@ impl<'a, C, NC, A> BookshelveGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// ID of user for whom to retrieve bookshelves. - pub fn user_id(mut self, new_value: &str) -> BookshelveGetCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> BookshelveGetCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -8177,7 +8173,7 @@ impl<'a, C, NC, A> BookshelveGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// ID of bookshelf to retrieve. - pub fn shelf(mut self, new_value: &str) -> BookshelveGetCall<'a, C, NC, A> { + pub fn shelf(mut self, new_value: &str) -> BookshelveGetCall<'a, C, A> { self._shelf = new_value.to_string(); self } @@ -8185,7 +8181,7 @@ impl<'a, C, NC, A> BookshelveGetCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> BookshelveGetCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> BookshelveGetCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -8196,7 +8192,7 @@ impl<'a, C, NC, A> BookshelveGetCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BookshelveGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BookshelveGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8217,7 +8213,7 @@ impl<'a, C, NC, A> BookshelveGetCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BookshelveGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BookshelveGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8234,7 +8230,7 @@ impl<'a, C, NC, A> BookshelveGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BookshelveGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BookshelveGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8280,10 +8276,10 @@ impl<'a, C, NC, A> BookshelveGetCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct PromoofferAcceptCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PromoofferAcceptCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _volume_id: Option, _serial: Option, _product: Option, @@ -8297,9 +8293,9 @@ pub struct PromoofferAcceptCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PromoofferAcceptCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PromoofferAcceptCall<'a, C, A> {} -impl<'a, C, NC, A> PromoofferAcceptCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PromoofferAcceptCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8417,7 +8413,7 @@ impl<'a, C, NC, A> PromoofferAcceptCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Volume id to exercise the offer - pub fn volume_id(mut self, new_value: &str) -> PromoofferAcceptCall<'a, C, NC, A> { + pub fn volume_id(mut self, new_value: &str) -> PromoofferAcceptCall<'a, C, A> { self._volume_id = Some(new_value.to_string()); self } @@ -8425,7 +8421,7 @@ impl<'a, C, NC, A> PromoofferAcceptCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// device serial - pub fn serial(mut self, new_value: &str) -> PromoofferAcceptCall<'a, C, NC, A> { + pub fn serial(mut self, new_value: &str) -> PromoofferAcceptCall<'a, C, A> { self._serial = Some(new_value.to_string()); self } @@ -8433,14 +8429,14 @@ impl<'a, C, NC, A> PromoofferAcceptCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// device product - pub fn product(mut self, new_value: &str) -> PromoofferAcceptCall<'a, C, NC, A> { + pub fn product(mut self, new_value: &str) -> PromoofferAcceptCall<'a, C, A> { self._product = Some(new_value.to_string()); self } /// Sets the *offer id* query property to the given value. /// /// - pub fn offer_id(mut self, new_value: &str) -> PromoofferAcceptCall<'a, C, NC, A> { + pub fn offer_id(mut self, new_value: &str) -> PromoofferAcceptCall<'a, C, A> { self._offer_id = Some(new_value.to_string()); self } @@ -8448,7 +8444,7 @@ impl<'a, C, NC, A> PromoofferAcceptCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// device model - pub fn model(mut self, new_value: &str) -> PromoofferAcceptCall<'a, C, NC, A> { + pub fn model(mut self, new_value: &str) -> PromoofferAcceptCall<'a, C, A> { self._model = Some(new_value.to_string()); self } @@ -8456,7 +8452,7 @@ impl<'a, C, NC, A> PromoofferAcceptCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// device manufacturer - pub fn manufacturer(mut self, new_value: &str) -> PromoofferAcceptCall<'a, C, NC, A> { + pub fn manufacturer(mut self, new_value: &str) -> PromoofferAcceptCall<'a, C, A> { self._manufacturer = Some(new_value.to_string()); self } @@ -8464,7 +8460,7 @@ impl<'a, C, NC, A> PromoofferAcceptCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// device device - pub fn device(mut self, new_value: &str) -> PromoofferAcceptCall<'a, C, NC, A> { + pub fn device(mut self, new_value: &str) -> PromoofferAcceptCall<'a, C, A> { self._device = Some(new_value.to_string()); self } @@ -8472,7 +8468,7 @@ impl<'a, C, NC, A> PromoofferAcceptCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// device android_id - pub fn android_id(mut self, new_value: &str) -> PromoofferAcceptCall<'a, C, NC, A> { + pub fn android_id(mut self, new_value: &str) -> PromoofferAcceptCall<'a, C, A> { self._android_id = Some(new_value.to_string()); self } @@ -8483,7 +8479,7 @@ impl<'a, C, NC, A> PromoofferAcceptCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PromoofferAcceptCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PromoofferAcceptCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8504,7 +8500,7 @@ impl<'a, C, NC, A> PromoofferAcceptCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PromoofferAcceptCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PromoofferAcceptCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8521,7 +8517,7 @@ impl<'a, C, NC, A> PromoofferAcceptCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PromoofferAcceptCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PromoofferAcceptCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8566,10 +8562,10 @@ impl<'a, C, NC, A> PromoofferAcceptCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct PromoofferDismisCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PromoofferDismisCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _serial: Option, _product: Option, _offer_id: Option, @@ -8582,9 +8578,9 @@ pub struct PromoofferDismisCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PromoofferDismisCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PromoofferDismisCall<'a, C, A> {} -impl<'a, C, NC, A> PromoofferDismisCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PromoofferDismisCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8699,7 +8695,7 @@ impl<'a, C, NC, A> PromoofferDismisCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// device serial - pub fn serial(mut self, new_value: &str) -> PromoofferDismisCall<'a, C, NC, A> { + pub fn serial(mut self, new_value: &str) -> PromoofferDismisCall<'a, C, A> { self._serial = Some(new_value.to_string()); self } @@ -8707,7 +8703,7 @@ impl<'a, C, NC, A> PromoofferDismisCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// device product - pub fn product(mut self, new_value: &str) -> PromoofferDismisCall<'a, C, NC, A> { + pub fn product(mut self, new_value: &str) -> PromoofferDismisCall<'a, C, A> { self._product = Some(new_value.to_string()); self } @@ -8715,7 +8711,7 @@ impl<'a, C, NC, A> PromoofferDismisCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Offer to dimiss - pub fn offer_id(mut self, new_value: &str) -> PromoofferDismisCall<'a, C, NC, A> { + pub fn offer_id(mut self, new_value: &str) -> PromoofferDismisCall<'a, C, A> { self._offer_id = Some(new_value.to_string()); self } @@ -8723,7 +8719,7 @@ impl<'a, C, NC, A> PromoofferDismisCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// device model - pub fn model(mut self, new_value: &str) -> PromoofferDismisCall<'a, C, NC, A> { + pub fn model(mut self, new_value: &str) -> PromoofferDismisCall<'a, C, A> { self._model = Some(new_value.to_string()); self } @@ -8731,7 +8727,7 @@ impl<'a, C, NC, A> PromoofferDismisCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// device manufacturer - pub fn manufacturer(mut self, new_value: &str) -> PromoofferDismisCall<'a, C, NC, A> { + pub fn manufacturer(mut self, new_value: &str) -> PromoofferDismisCall<'a, C, A> { self._manufacturer = Some(new_value.to_string()); self } @@ -8739,7 +8735,7 @@ impl<'a, C, NC, A> PromoofferDismisCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// device device - pub fn device(mut self, new_value: &str) -> PromoofferDismisCall<'a, C, NC, A> { + pub fn device(mut self, new_value: &str) -> PromoofferDismisCall<'a, C, A> { self._device = Some(new_value.to_string()); self } @@ -8747,7 +8743,7 @@ impl<'a, C, NC, A> PromoofferDismisCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// device android_id - pub fn android_id(mut self, new_value: &str) -> PromoofferDismisCall<'a, C, NC, A> { + pub fn android_id(mut self, new_value: &str) -> PromoofferDismisCall<'a, C, A> { self._android_id = Some(new_value.to_string()); self } @@ -8758,7 +8754,7 @@ impl<'a, C, NC, A> PromoofferDismisCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PromoofferDismisCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PromoofferDismisCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8779,7 +8775,7 @@ impl<'a, C, NC, A> PromoofferDismisCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PromoofferDismisCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PromoofferDismisCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8796,7 +8792,7 @@ impl<'a, C, NC, A> PromoofferDismisCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PromoofferDismisCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PromoofferDismisCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8840,10 +8836,10 @@ impl<'a, C, NC, A> PromoofferDismisCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct PromoofferGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PromoofferGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _serial: Option, _product: Option, _model: Option, @@ -8855,9 +8851,9 @@ pub struct PromoofferGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PromoofferGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PromoofferGetCall<'a, C, A> {} -impl<'a, C, NC, A> PromoofferGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PromoofferGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8980,7 +8976,7 @@ impl<'a, C, NC, A> PromoofferGetCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// device serial - pub fn serial(mut self, new_value: &str) -> PromoofferGetCall<'a, C, NC, A> { + pub fn serial(mut self, new_value: &str) -> PromoofferGetCall<'a, C, A> { self._serial = Some(new_value.to_string()); self } @@ -8988,7 +8984,7 @@ impl<'a, C, NC, A> PromoofferGetCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// device product - pub fn product(mut self, new_value: &str) -> PromoofferGetCall<'a, C, NC, A> { + pub fn product(mut self, new_value: &str) -> PromoofferGetCall<'a, C, A> { self._product = Some(new_value.to_string()); self } @@ -8996,7 +8992,7 @@ impl<'a, C, NC, A> PromoofferGetCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// device model - pub fn model(mut self, new_value: &str) -> PromoofferGetCall<'a, C, NC, A> { + pub fn model(mut self, new_value: &str) -> PromoofferGetCall<'a, C, A> { self._model = Some(new_value.to_string()); self } @@ -9004,7 +9000,7 @@ impl<'a, C, NC, A> PromoofferGetCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// device manufacturer - pub fn manufacturer(mut self, new_value: &str) -> PromoofferGetCall<'a, C, NC, A> { + pub fn manufacturer(mut self, new_value: &str) -> PromoofferGetCall<'a, C, A> { self._manufacturer = Some(new_value.to_string()); self } @@ -9012,7 +9008,7 @@ impl<'a, C, NC, A> PromoofferGetCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// device device - pub fn device(mut self, new_value: &str) -> PromoofferGetCall<'a, C, NC, A> { + pub fn device(mut self, new_value: &str) -> PromoofferGetCall<'a, C, A> { self._device = Some(new_value.to_string()); self } @@ -9020,7 +9016,7 @@ impl<'a, C, NC, A> PromoofferGetCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// device android_id - pub fn android_id(mut self, new_value: &str) -> PromoofferGetCall<'a, C, NC, A> { + pub fn android_id(mut self, new_value: &str) -> PromoofferGetCall<'a, C, A> { self._android_id = Some(new_value.to_string()); self } @@ -9031,7 +9027,7 @@ impl<'a, C, NC, A> PromoofferGetCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PromoofferGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PromoofferGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9052,7 +9048,7 @@ impl<'a, C, NC, A> PromoofferGetCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PromoofferGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PromoofferGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9069,7 +9065,7 @@ impl<'a, C, NC, A> PromoofferGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PromoofferGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PromoofferGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9108,19 +9104,19 @@ impl<'a, C, NC, A> PromoofferGetCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct OnboardingListCategoryCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct OnboardingListCategoryCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _locale: Option, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for OnboardingListCategoryCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for OnboardingListCategoryCall<'a, C, A> {} -impl<'a, C, NC, A> OnboardingListCategoryCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> OnboardingListCategoryCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9228,7 +9224,7 @@ impl<'a, C, NC, A> OnboardingListCategoryCall<'a, C, NC, A> where NC: hyper::net /// /// /// ISO-639-1 language and ISO-3166-1 country code. Default is en-US if unset. - pub fn locale(mut self, new_value: &str) -> OnboardingListCategoryCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> OnboardingListCategoryCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -9239,7 +9235,7 @@ impl<'a, C, NC, A> OnboardingListCategoryCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> OnboardingListCategoryCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> OnboardingListCategoryCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9260,7 +9256,7 @@ impl<'a, C, NC, A> OnboardingListCategoryCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> OnboardingListCategoryCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> OnboardingListCategoryCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9277,7 +9273,7 @@ impl<'a, C, NC, A> OnboardingListCategoryCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> OnboardingListCategoryCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> OnboardingListCategoryCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9319,10 +9315,10 @@ impl<'a, C, NC, A> OnboardingListCategoryCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct OnboardingListCategoryVolumeCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct OnboardingListCategoryVolumeCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _page_token: Option, _page_size: Option, _locale: Option, @@ -9332,9 +9328,9 @@ pub struct OnboardingListCategoryVolumeCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for OnboardingListCategoryVolumeCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for OnboardingListCategoryVolumeCall<'a, C, A> {} -impl<'a, C, NC, A> OnboardingListCategoryVolumeCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> OnboardingListCategoryVolumeCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9455,7 +9451,7 @@ impl<'a, C, NC, A> OnboardingListCategoryVolumeCall<'a, C, NC, A> where NC: hype /// /// /// The value of the nextToken from the previous page. - pub fn page_token(mut self, new_value: &str) -> OnboardingListCategoryVolumeCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> OnboardingListCategoryVolumeCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -9463,7 +9459,7 @@ impl<'a, C, NC, A> OnboardingListCategoryVolumeCall<'a, C, NC, A> where NC: hype /// /// /// Number of maximum results per page to be included in the response. - pub fn page_size(mut self, new_value: u32) -> OnboardingListCategoryVolumeCall<'a, C, NC, A> { + pub fn page_size(mut self, new_value: u32) -> OnboardingListCategoryVolumeCall<'a, C, A> { self._page_size = Some(new_value); self } @@ -9471,7 +9467,7 @@ impl<'a, C, NC, A> OnboardingListCategoryVolumeCall<'a, C, NC, A> where NC: hype /// /// /// ISO-639-1 language and ISO-3166-1 country code. Default is en-US if unset. - pub fn locale(mut self, new_value: &str) -> OnboardingListCategoryVolumeCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> OnboardingListCategoryVolumeCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -9480,7 +9476,7 @@ impl<'a, C, NC, A> OnboardingListCategoryVolumeCall<'a, C, NC, A> where NC: hype /// /// /// List of category ids requested. - pub fn add_category_id(mut self, new_value: &str) -> OnboardingListCategoryVolumeCall<'a, C, NC, A> { + pub fn add_category_id(mut self, new_value: &str) -> OnboardingListCategoryVolumeCall<'a, C, A> { self._category_id.push(new_value.to_string()); self } @@ -9491,7 +9487,7 @@ impl<'a, C, NC, A> OnboardingListCategoryVolumeCall<'a, C, NC, A> where NC: hype /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> OnboardingListCategoryVolumeCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> OnboardingListCategoryVolumeCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9512,7 +9508,7 @@ impl<'a, C, NC, A> OnboardingListCategoryVolumeCall<'a, C, NC, A> where NC: hype /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> OnboardingListCategoryVolumeCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> OnboardingListCategoryVolumeCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9529,7 +9525,7 @@ impl<'a, C, NC, A> OnboardingListCategoryVolumeCall<'a, C, NC, A> where NC: hype /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> OnboardingListCategoryVolumeCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> OnboardingListCategoryVolumeCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9569,10 +9565,10 @@ impl<'a, C, NC, A> OnboardingListCategoryVolumeCall<'a, C, NC, A> where NC: hype /// .doit(); /// # } /// ``` -pub struct MyconfigRequestAccesCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MyconfigRequestAccesCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _source: String, _volume_id: String, _nonce: String, @@ -9584,9 +9580,9 @@ pub struct MyconfigRequestAccesCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MyconfigRequestAccesCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MyconfigRequestAccesCall<'a, C, A> {} -impl<'a, C, NC, A> MyconfigRequestAccesCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MyconfigRequestAccesCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9703,7 +9699,7 @@ impl<'a, C, NC, A> MyconfigRequestAccesCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> MyconfigRequestAccesCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> MyconfigRequestAccesCall<'a, C, A> { self._source = new_value.to_string(); self } @@ -9713,7 +9709,7 @@ impl<'a, C, NC, A> MyconfigRequestAccesCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The volume to request concurrent/download restrictions for. - pub fn volume_id(mut self, new_value: &str) -> MyconfigRequestAccesCall<'a, C, NC, A> { + pub fn volume_id(mut self, new_value: &str) -> MyconfigRequestAccesCall<'a, C, A> { self._volume_id = new_value.to_string(); self } @@ -9723,7 +9719,7 @@ impl<'a, C, NC, A> MyconfigRequestAccesCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The client nonce value. - pub fn nonce(mut self, new_value: &str) -> MyconfigRequestAccesCall<'a, C, NC, A> { + pub fn nonce(mut self, new_value: &str) -> MyconfigRequestAccesCall<'a, C, A> { self._nonce = new_value.to_string(); self } @@ -9733,7 +9729,7 @@ impl<'a, C, NC, A> MyconfigRequestAccesCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The device/version ID from which to request the restrictions. - pub fn cpksver(mut self, new_value: &str) -> MyconfigRequestAccesCall<'a, C, NC, A> { + pub fn cpksver(mut self, new_value: &str) -> MyconfigRequestAccesCall<'a, C, A> { self._cpksver = new_value.to_string(); self } @@ -9741,7 +9737,7 @@ impl<'a, C, NC, A> MyconfigRequestAccesCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// ISO-639-1, ISO-3166-1 codes for message localization, i.e. en_US. - pub fn locale(mut self, new_value: &str) -> MyconfigRequestAccesCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> MyconfigRequestAccesCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -9749,7 +9745,7 @@ impl<'a, C, NC, A> MyconfigRequestAccesCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// The type of access license to request. If not specified, the default is BOTH. - pub fn license_types(mut self, new_value: &str) -> MyconfigRequestAccesCall<'a, C, NC, A> { + pub fn license_types(mut self, new_value: &str) -> MyconfigRequestAccesCall<'a, C, A> { self._license_types = Some(new_value.to_string()); self } @@ -9760,7 +9756,7 @@ impl<'a, C, NC, A> MyconfigRequestAccesCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MyconfigRequestAccesCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MyconfigRequestAccesCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9781,7 +9777,7 @@ impl<'a, C, NC, A> MyconfigRequestAccesCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MyconfigRequestAccesCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MyconfigRequestAccesCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9798,7 +9794,7 @@ impl<'a, C, NC, A> MyconfigRequestAccesCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MyconfigRequestAccesCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MyconfigRequestAccesCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9838,10 +9834,10 @@ impl<'a, C, NC, A> MyconfigRequestAccesCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct MyconfigReleaseDownloadAccesCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MyconfigReleaseDownloadAccesCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _volume_ids: Vec, _cpksver: String, _source: Option, @@ -9851,9 +9847,9 @@ pub struct MyconfigReleaseDownloadAccesCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MyconfigReleaseDownloadAccesCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MyconfigReleaseDownloadAccesCall<'a, C, A> {} -impl<'a, C, NC, A> MyconfigReleaseDownloadAccesCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MyconfigReleaseDownloadAccesCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9975,7 +9971,7 @@ impl<'a, C, NC, A> MyconfigReleaseDownloadAccesCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// The volume(s) to release restrictions for. - pub fn add_volume_ids(mut self, new_value: &str) -> MyconfigReleaseDownloadAccesCall<'a, C, NC, A> { + pub fn add_volume_ids(mut self, new_value: &str) -> MyconfigReleaseDownloadAccesCall<'a, C, A> { self._volume_ids.push(new_value.to_string()); self } @@ -9985,7 +9981,7 @@ impl<'a, C, NC, A> MyconfigReleaseDownloadAccesCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// The device/version ID from which to release the restriction. - pub fn cpksver(mut self, new_value: &str) -> MyconfigReleaseDownloadAccesCall<'a, C, NC, A> { + pub fn cpksver(mut self, new_value: &str) -> MyconfigReleaseDownloadAccesCall<'a, C, A> { self._cpksver = new_value.to_string(); self } @@ -9993,7 +9989,7 @@ impl<'a, C, NC, A> MyconfigReleaseDownloadAccesCall<'a, C, NC, A> where NC: hype /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> MyconfigReleaseDownloadAccesCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> MyconfigReleaseDownloadAccesCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -10001,7 +9997,7 @@ impl<'a, C, NC, A> MyconfigReleaseDownloadAccesCall<'a, C, NC, A> where NC: hype /// /// /// ISO-639-1, ISO-3166-1 codes for message localization, i.e. en_US. - pub fn locale(mut self, new_value: &str) -> MyconfigReleaseDownloadAccesCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> MyconfigReleaseDownloadAccesCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -10012,7 +10008,7 @@ impl<'a, C, NC, A> MyconfigReleaseDownloadAccesCall<'a, C, NC, A> where NC: hype /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MyconfigReleaseDownloadAccesCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MyconfigReleaseDownloadAccesCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10033,7 +10029,7 @@ impl<'a, C, NC, A> MyconfigReleaseDownloadAccesCall<'a, C, NC, A> where NC: hype /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MyconfigReleaseDownloadAccesCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MyconfigReleaseDownloadAccesCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10050,7 +10046,7 @@ impl<'a, C, NC, A> MyconfigReleaseDownloadAccesCall<'a, C, NC, A> where NC: hype /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MyconfigReleaseDownloadAccesCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MyconfigReleaseDownloadAccesCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10092,10 +10088,10 @@ impl<'a, C, NC, A> MyconfigReleaseDownloadAccesCall<'a, C, NC, A> where NC: hype /// .doit(); /// # } /// ``` -pub struct MyconfigSyncVolumeLicenseCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MyconfigSyncVolumeLicenseCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _source: String, _nonce: String, _cpksver: String, @@ -10108,9 +10104,9 @@ pub struct MyconfigSyncVolumeLicenseCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MyconfigSyncVolumeLicenseCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MyconfigSyncVolumeLicenseCall<'a, C, A> {} -impl<'a, C, NC, A> MyconfigSyncVolumeLicenseCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MyconfigSyncVolumeLicenseCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10240,7 +10236,7 @@ impl<'a, C, NC, A> MyconfigSyncVolumeLicenseCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> MyconfigSyncVolumeLicenseCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> MyconfigSyncVolumeLicenseCall<'a, C, A> { self._source = new_value.to_string(); self } @@ -10250,7 +10246,7 @@ impl<'a, C, NC, A> MyconfigSyncVolumeLicenseCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The client nonce value. - pub fn nonce(mut self, new_value: &str) -> MyconfigSyncVolumeLicenseCall<'a, C, NC, A> { + pub fn nonce(mut self, new_value: &str) -> MyconfigSyncVolumeLicenseCall<'a, C, A> { self._nonce = new_value.to_string(); self } @@ -10260,7 +10256,7 @@ impl<'a, C, NC, A> MyconfigSyncVolumeLicenseCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The device/version ID from which to release the restriction. - pub fn cpksver(mut self, new_value: &str) -> MyconfigSyncVolumeLicenseCall<'a, C, NC, A> { + pub fn cpksver(mut self, new_value: &str) -> MyconfigSyncVolumeLicenseCall<'a, C, A> { self._cpksver = new_value.to_string(); self } @@ -10269,7 +10265,7 @@ impl<'a, C, NC, A> MyconfigSyncVolumeLicenseCall<'a, C, NC, A> where NC: hyper:: /// /// /// The volume(s) to request download restrictions for. - pub fn add_volume_ids(mut self, new_value: &str) -> MyconfigSyncVolumeLicenseCall<'a, C, NC, A> { + pub fn add_volume_ids(mut self, new_value: &str) -> MyconfigSyncVolumeLicenseCall<'a, C, A> { self._volume_ids.push(new_value.to_string()); self } @@ -10277,7 +10273,7 @@ impl<'a, C, NC, A> MyconfigSyncVolumeLicenseCall<'a, C, NC, A> where NC: hyper:: /// /// /// Set to true to show pre-ordered books. Defaults to false. - pub fn show_preorders(mut self, new_value: bool) -> MyconfigSyncVolumeLicenseCall<'a, C, NC, A> { + pub fn show_preorders(mut self, new_value: bool) -> MyconfigSyncVolumeLicenseCall<'a, C, A> { self._show_preorders = Some(new_value); self } @@ -10285,7 +10281,7 @@ impl<'a, C, NC, A> MyconfigSyncVolumeLicenseCall<'a, C, NC, A> where NC: hyper:: /// /// /// ISO-639-1, ISO-3166-1 codes for message localization, i.e. en_US. - pub fn locale(mut self, new_value: &str) -> MyconfigSyncVolumeLicenseCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> MyconfigSyncVolumeLicenseCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -10294,7 +10290,7 @@ impl<'a, C, NC, A> MyconfigSyncVolumeLicenseCall<'a, C, NC, A> where NC: hyper:: /// /// /// List of features supported by the client, i.e., 'RENTALS' - pub fn add_features(mut self, new_value: &str) -> MyconfigSyncVolumeLicenseCall<'a, C, NC, A> { + pub fn add_features(mut self, new_value: &str) -> MyconfigSyncVolumeLicenseCall<'a, C, A> { self._features.push(new_value.to_string()); self } @@ -10305,7 +10301,7 @@ impl<'a, C, NC, A> MyconfigSyncVolumeLicenseCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MyconfigSyncVolumeLicenseCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MyconfigSyncVolumeLicenseCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10326,7 +10322,7 @@ impl<'a, C, NC, A> MyconfigSyncVolumeLicenseCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MyconfigSyncVolumeLicenseCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MyconfigSyncVolumeLicenseCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10343,7 +10339,7 @@ impl<'a, C, NC, A> MyconfigSyncVolumeLicenseCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MyconfigSyncVolumeLicenseCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MyconfigSyncVolumeLicenseCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10381,18 +10377,18 @@ impl<'a, C, NC, A> MyconfigSyncVolumeLicenseCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct MyconfigGetUserSettingCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MyconfigGetUserSettingCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MyconfigGetUserSettingCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MyconfigGetUserSettingCall<'a, C, A> {} -impl<'a, C, NC, A> MyconfigGetUserSettingCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MyconfigGetUserSettingCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10500,7 +10496,7 @@ impl<'a, C, NC, A> MyconfigGetUserSettingCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MyconfigGetUserSettingCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MyconfigGetUserSettingCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10521,7 +10517,7 @@ impl<'a, C, NC, A> MyconfigGetUserSettingCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MyconfigGetUserSettingCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MyconfigGetUserSettingCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10538,7 +10534,7 @@ impl<'a, C, NC, A> MyconfigGetUserSettingCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MyconfigGetUserSettingCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MyconfigGetUserSettingCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10582,19 +10578,19 @@ impl<'a, C, NC, A> MyconfigGetUserSettingCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct MyconfigUpdateUserSettingCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MyconfigUpdateUserSettingCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _request: Usersettings, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MyconfigUpdateUserSettingCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MyconfigUpdateUserSettingCall<'a, C, A> {} -impl<'a, C, NC, A> MyconfigUpdateUserSettingCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MyconfigUpdateUserSettingCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10708,7 +10704,7 @@ impl<'a, C, NC, A> MyconfigUpdateUserSettingCall<'a, C, NC, A> where NC: hyper:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Usersettings) -> MyconfigUpdateUserSettingCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Usersettings) -> MyconfigUpdateUserSettingCall<'a, C, A> { self._request = new_value.clone(); self } @@ -10719,7 +10715,7 @@ impl<'a, C, NC, A> MyconfigUpdateUserSettingCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MyconfigUpdateUserSettingCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MyconfigUpdateUserSettingCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10740,7 +10736,7 @@ impl<'a, C, NC, A> MyconfigUpdateUserSettingCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MyconfigUpdateUserSettingCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MyconfigUpdateUserSettingCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10757,7 +10753,7 @@ impl<'a, C, NC, A> MyconfigUpdateUserSettingCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MyconfigUpdateUserSettingCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MyconfigUpdateUserSettingCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10796,10 +10792,10 @@ impl<'a, C, NC, A> MyconfigUpdateUserSettingCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct MylibraryBookshelveClearVolumeCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MylibraryBookshelveClearVolumeCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _shelf: String, _source: Option, _delegate: Option<&'a mut Delegate>, @@ -10807,9 +10803,9 @@ pub struct MylibraryBookshelveClearVolumeCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MylibraryBookshelveClearVolumeCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MylibraryBookshelveClearVolumeCall<'a, C, A> {} -impl<'a, C, NC, A> MylibraryBookshelveClearVolumeCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MylibraryBookshelveClearVolumeCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10933,7 +10929,7 @@ impl<'a, C, NC, A> MylibraryBookshelveClearVolumeCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// ID of bookshelf from which to remove a volume. - pub fn shelf(mut self, new_value: &str) -> MylibraryBookshelveClearVolumeCall<'a, C, NC, A> { + pub fn shelf(mut self, new_value: &str) -> MylibraryBookshelveClearVolumeCall<'a, C, A> { self._shelf = new_value.to_string(); self } @@ -10941,7 +10937,7 @@ impl<'a, C, NC, A> MylibraryBookshelveClearVolumeCall<'a, C, NC, A> where NC: hy /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> MylibraryBookshelveClearVolumeCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> MylibraryBookshelveClearVolumeCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -10952,7 +10948,7 @@ impl<'a, C, NC, A> MylibraryBookshelveClearVolumeCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryBookshelveClearVolumeCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryBookshelveClearVolumeCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10973,7 +10969,7 @@ impl<'a, C, NC, A> MylibraryBookshelveClearVolumeCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MylibraryBookshelveClearVolumeCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MylibraryBookshelveClearVolumeCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10990,7 +10986,7 @@ impl<'a, C, NC, A> MylibraryBookshelveClearVolumeCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MylibraryBookshelveClearVolumeCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MylibraryBookshelveClearVolumeCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11029,10 +11025,10 @@ impl<'a, C, NC, A> MylibraryBookshelveClearVolumeCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct MylibraryBookshelveMoveVolumeCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MylibraryBookshelveMoveVolumeCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _shelf: String, _volume_id: String, _volume_position: i32, @@ -11042,9 +11038,9 @@ pub struct MylibraryBookshelveMoveVolumeCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MylibraryBookshelveMoveVolumeCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MylibraryBookshelveMoveVolumeCall<'a, C, A> {} -impl<'a, C, NC, A> MylibraryBookshelveMoveVolumeCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MylibraryBookshelveMoveVolumeCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11170,7 +11166,7 @@ impl<'a, C, NC, A> MylibraryBookshelveMoveVolumeCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// ID of bookshelf with the volume. - pub fn shelf(mut self, new_value: &str) -> MylibraryBookshelveMoveVolumeCall<'a, C, NC, A> { + pub fn shelf(mut self, new_value: &str) -> MylibraryBookshelveMoveVolumeCall<'a, C, A> { self._shelf = new_value.to_string(); self } @@ -11180,7 +11176,7 @@ impl<'a, C, NC, A> MylibraryBookshelveMoveVolumeCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// ID of volume to move. - pub fn volume_id(mut self, new_value: &str) -> MylibraryBookshelveMoveVolumeCall<'a, C, NC, A> { + pub fn volume_id(mut self, new_value: &str) -> MylibraryBookshelveMoveVolumeCall<'a, C, A> { self._volume_id = new_value.to_string(); self } @@ -11190,7 +11186,7 @@ impl<'a, C, NC, A> MylibraryBookshelveMoveVolumeCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// Position on shelf to move the item (0 puts the item before the current first item, 1 puts it between the first and the second and so on.) - pub fn volume_position(mut self, new_value: i32) -> MylibraryBookshelveMoveVolumeCall<'a, C, NC, A> { + pub fn volume_position(mut self, new_value: i32) -> MylibraryBookshelveMoveVolumeCall<'a, C, A> { self._volume_position = new_value; self } @@ -11198,7 +11194,7 @@ impl<'a, C, NC, A> MylibraryBookshelveMoveVolumeCall<'a, C, NC, A> where NC: hyp /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> MylibraryBookshelveMoveVolumeCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> MylibraryBookshelveMoveVolumeCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -11209,7 +11205,7 @@ impl<'a, C, NC, A> MylibraryBookshelveMoveVolumeCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryBookshelveMoveVolumeCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryBookshelveMoveVolumeCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11230,7 +11226,7 @@ impl<'a, C, NC, A> MylibraryBookshelveMoveVolumeCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MylibraryBookshelveMoveVolumeCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MylibraryBookshelveMoveVolumeCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11247,7 +11243,7 @@ impl<'a, C, NC, A> MylibraryBookshelveMoveVolumeCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MylibraryBookshelveMoveVolumeCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MylibraryBookshelveMoveVolumeCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11292,10 +11288,10 @@ impl<'a, C, NC, A> MylibraryBookshelveMoveVolumeCall<'a, C, NC, A> where NC: hyp /// .doit(); /// # } /// ``` -pub struct MylibraryBookshelveVolumeListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MylibraryBookshelveVolumeListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _shelf: String, _start_index: Option, _source: Option, @@ -11309,9 +11305,9 @@ pub struct MylibraryBookshelveVolumeListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MylibraryBookshelveVolumeListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MylibraryBookshelveVolumeListCall<'a, C, A> {} -impl<'a, C, NC, A> MylibraryBookshelveVolumeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MylibraryBookshelveVolumeListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11464,7 +11460,7 @@ impl<'a, C, NC, A> MylibraryBookshelveVolumeListCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// The bookshelf ID or name retrieve volumes for. - pub fn shelf(mut self, new_value: &str) -> MylibraryBookshelveVolumeListCall<'a, C, NC, A> { + pub fn shelf(mut self, new_value: &str) -> MylibraryBookshelveVolumeListCall<'a, C, A> { self._shelf = new_value.to_string(); self } @@ -11472,7 +11468,7 @@ impl<'a, C, NC, A> MylibraryBookshelveVolumeListCall<'a, C, NC, A> where NC: hyp /// /// /// Index of the first element to return (starts at 0) - pub fn start_index(mut self, new_value: u32) -> MylibraryBookshelveVolumeListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: u32) -> MylibraryBookshelveVolumeListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -11480,7 +11476,7 @@ impl<'a, C, NC, A> MylibraryBookshelveVolumeListCall<'a, C, NC, A> where NC: hyp /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> MylibraryBookshelveVolumeListCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> MylibraryBookshelveVolumeListCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -11488,7 +11484,7 @@ impl<'a, C, NC, A> MylibraryBookshelveVolumeListCall<'a, C, NC, A> where NC: hyp /// /// /// Set to true to show pre-ordered books. Defaults to false. - pub fn show_preorders(mut self, new_value: bool) -> MylibraryBookshelveVolumeListCall<'a, C, NC, A> { + pub fn show_preorders(mut self, new_value: bool) -> MylibraryBookshelveVolumeListCall<'a, C, A> { self._show_preorders = Some(new_value); self } @@ -11496,7 +11492,7 @@ impl<'a, C, NC, A> MylibraryBookshelveVolumeListCall<'a, C, NC, A> where NC: hyp /// /// /// Full-text search query string in this bookshelf. - pub fn q(mut self, new_value: &str) -> MylibraryBookshelveVolumeListCall<'a, C, NC, A> { + pub fn q(mut self, new_value: &str) -> MylibraryBookshelveVolumeListCall<'a, C, A> { self._q = Some(new_value.to_string()); self } @@ -11504,7 +11500,7 @@ impl<'a, C, NC, A> MylibraryBookshelveVolumeListCall<'a, C, NC, A> where NC: hyp /// /// /// Restrict information returned to a set of selected fields. - pub fn projection(mut self, new_value: &str) -> MylibraryBookshelveVolumeListCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> MylibraryBookshelveVolumeListCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -11512,7 +11508,7 @@ impl<'a, C, NC, A> MylibraryBookshelveVolumeListCall<'a, C, NC, A> where NC: hyp /// /// /// Maximum number of results to return - pub fn max_results(mut self, new_value: u32) -> MylibraryBookshelveVolumeListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> MylibraryBookshelveVolumeListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -11520,7 +11516,7 @@ impl<'a, C, NC, A> MylibraryBookshelveVolumeListCall<'a, C, NC, A> where NC: hyp /// /// /// ISO-3166-1 code to override the IP-based location. - pub fn country(mut self, new_value: &str) -> MylibraryBookshelveVolumeListCall<'a, C, NC, A> { + pub fn country(mut self, new_value: &str) -> MylibraryBookshelveVolumeListCall<'a, C, A> { self._country = Some(new_value.to_string()); self } @@ -11531,7 +11527,7 @@ impl<'a, C, NC, A> MylibraryBookshelveVolumeListCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryBookshelveVolumeListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryBookshelveVolumeListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11552,7 +11548,7 @@ impl<'a, C, NC, A> MylibraryBookshelveVolumeListCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MylibraryBookshelveVolumeListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MylibraryBookshelveVolumeListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11569,7 +11565,7 @@ impl<'a, C, NC, A> MylibraryBookshelveVolumeListCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MylibraryBookshelveVolumeListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MylibraryBookshelveVolumeListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11607,10 +11603,10 @@ impl<'a, C, NC, A> MylibraryBookshelveVolumeListCall<'a, C, NC, A> where NC: hyp /// .doit(); /// # } /// ``` -pub struct MylibraryAnnotationSummaryCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MylibraryAnnotationSummaryCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _layer_ids: Vec, _volume_id: String, _delegate: Option<&'a mut Delegate>, @@ -11618,9 +11614,9 @@ pub struct MylibraryAnnotationSummaryCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MylibraryAnnotationSummaryCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MylibraryAnnotationSummaryCall<'a, C, A> {} -impl<'a, C, NC, A> MylibraryAnnotationSummaryCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MylibraryAnnotationSummaryCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11736,7 +11732,7 @@ impl<'a, C, NC, A> MylibraryAnnotationSummaryCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Array of layer IDs to get the summary for. - pub fn add_layer_ids(mut self, new_value: &str) -> MylibraryAnnotationSummaryCall<'a, C, NC, A> { + pub fn add_layer_ids(mut self, new_value: &str) -> MylibraryAnnotationSummaryCall<'a, C, A> { self._layer_ids.push(new_value.to_string()); self } @@ -11746,7 +11742,7 @@ impl<'a, C, NC, A> MylibraryAnnotationSummaryCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Volume id to get the summary for. - pub fn volume_id(mut self, new_value: &str) -> MylibraryAnnotationSummaryCall<'a, C, NC, A> { + pub fn volume_id(mut self, new_value: &str) -> MylibraryAnnotationSummaryCall<'a, C, A> { self._volume_id = new_value.to_string(); self } @@ -11757,7 +11753,7 @@ impl<'a, C, NC, A> MylibraryAnnotationSummaryCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryAnnotationSummaryCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryAnnotationSummaryCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11778,7 +11774,7 @@ impl<'a, C, NC, A> MylibraryAnnotationSummaryCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MylibraryAnnotationSummaryCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MylibraryAnnotationSummaryCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11795,7 +11791,7 @@ impl<'a, C, NC, A> MylibraryAnnotationSummaryCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MylibraryAnnotationSummaryCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MylibraryAnnotationSummaryCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11834,10 +11830,10 @@ impl<'a, C, NC, A> MylibraryAnnotationSummaryCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct MylibraryAnnotationDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MylibraryAnnotationDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _annotation_id: String, _source: Option, _delegate: Option<&'a mut Delegate>, @@ -11845,9 +11841,9 @@ pub struct MylibraryAnnotationDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MylibraryAnnotationDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MylibraryAnnotationDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> MylibraryAnnotationDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MylibraryAnnotationDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11971,7 +11967,7 @@ impl<'a, C, NC, A> MylibraryAnnotationDeleteCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The ID for the annotation to delete. - pub fn annotation_id(mut self, new_value: &str) -> MylibraryAnnotationDeleteCall<'a, C, NC, A> { + pub fn annotation_id(mut self, new_value: &str) -> MylibraryAnnotationDeleteCall<'a, C, A> { self._annotation_id = new_value.to_string(); self } @@ -11979,7 +11975,7 @@ impl<'a, C, NC, A> MylibraryAnnotationDeleteCall<'a, C, NC, A> where NC: hyper:: /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> MylibraryAnnotationDeleteCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> MylibraryAnnotationDeleteCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -11990,7 +11986,7 @@ impl<'a, C, NC, A> MylibraryAnnotationDeleteCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryAnnotationDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryAnnotationDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12011,7 +12007,7 @@ impl<'a, C, NC, A> MylibraryAnnotationDeleteCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MylibraryAnnotationDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MylibraryAnnotationDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12028,7 +12024,7 @@ impl<'a, C, NC, A> MylibraryAnnotationDeleteCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MylibraryAnnotationDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MylibraryAnnotationDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12068,10 +12064,10 @@ impl<'a, C, NC, A> MylibraryAnnotationDeleteCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct MylibraryBookshelveAddVolumeCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MylibraryBookshelveAddVolumeCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _shelf: String, _volume_id: String, _source: Option, @@ -12081,9 +12077,9 @@ pub struct MylibraryBookshelveAddVolumeCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MylibraryBookshelveAddVolumeCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MylibraryBookshelveAddVolumeCall<'a, C, A> {} -impl<'a, C, NC, A> MylibraryBookshelveAddVolumeCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MylibraryBookshelveAddVolumeCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12211,7 +12207,7 @@ impl<'a, C, NC, A> MylibraryBookshelveAddVolumeCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// ID of bookshelf to which to add a volume. - pub fn shelf(mut self, new_value: &str) -> MylibraryBookshelveAddVolumeCall<'a, C, NC, A> { + pub fn shelf(mut self, new_value: &str) -> MylibraryBookshelveAddVolumeCall<'a, C, A> { self._shelf = new_value.to_string(); self } @@ -12221,7 +12217,7 @@ impl<'a, C, NC, A> MylibraryBookshelveAddVolumeCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// ID of volume to add. - pub fn volume_id(mut self, new_value: &str) -> MylibraryBookshelveAddVolumeCall<'a, C, NC, A> { + pub fn volume_id(mut self, new_value: &str) -> MylibraryBookshelveAddVolumeCall<'a, C, A> { self._volume_id = new_value.to_string(); self } @@ -12229,7 +12225,7 @@ impl<'a, C, NC, A> MylibraryBookshelveAddVolumeCall<'a, C, NC, A> where NC: hype /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> MylibraryBookshelveAddVolumeCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> MylibraryBookshelveAddVolumeCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -12237,7 +12233,7 @@ impl<'a, C, NC, A> MylibraryBookshelveAddVolumeCall<'a, C, NC, A> where NC: hype /// /// /// The reason for which the book is added to the library. - pub fn reason(mut self, new_value: &str) -> MylibraryBookshelveAddVolumeCall<'a, C, NC, A> { + pub fn reason(mut self, new_value: &str) -> MylibraryBookshelveAddVolumeCall<'a, C, A> { self._reason = Some(new_value.to_string()); self } @@ -12248,7 +12244,7 @@ impl<'a, C, NC, A> MylibraryBookshelveAddVolumeCall<'a, C, NC, A> where NC: hype /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryBookshelveAddVolumeCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryBookshelveAddVolumeCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12269,7 +12265,7 @@ impl<'a, C, NC, A> MylibraryBookshelveAddVolumeCall<'a, C, NC, A> where NC: hype /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MylibraryBookshelveAddVolumeCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MylibraryBookshelveAddVolumeCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12286,7 +12282,7 @@ impl<'a, C, NC, A> MylibraryBookshelveAddVolumeCall<'a, C, NC, A> where NC: hype /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MylibraryBookshelveAddVolumeCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MylibraryBookshelveAddVolumeCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12333,10 +12329,10 @@ impl<'a, C, NC, A> MylibraryBookshelveAddVolumeCall<'a, C, NC, A> where NC: hype /// .doit(); /// # } /// ``` -pub struct MylibraryAnnotationInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MylibraryAnnotationInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _request: Annotation, _source: Option, _show_only_summary_in_response: Option, @@ -12346,9 +12342,9 @@ pub struct MylibraryAnnotationInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MylibraryAnnotationInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MylibraryAnnotationInsertCall<'a, C, A> {} -impl<'a, C, NC, A> MylibraryAnnotationInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MylibraryAnnotationInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12471,7 +12467,7 @@ impl<'a, C, NC, A> MylibraryAnnotationInsertCall<'a, C, NC, A> where NC: hyper:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Annotation) -> MylibraryAnnotationInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Annotation) -> MylibraryAnnotationInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -12479,7 +12475,7 @@ impl<'a, C, NC, A> MylibraryAnnotationInsertCall<'a, C, NC, A> where NC: hyper:: /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> MylibraryAnnotationInsertCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> MylibraryAnnotationInsertCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -12487,7 +12483,7 @@ impl<'a, C, NC, A> MylibraryAnnotationInsertCall<'a, C, NC, A> where NC: hyper:: /// /// /// Requests that only the summary of the specified layer be provided in the response. - pub fn show_only_summary_in_response(mut self, new_value: bool) -> MylibraryAnnotationInsertCall<'a, C, NC, A> { + pub fn show_only_summary_in_response(mut self, new_value: bool) -> MylibraryAnnotationInsertCall<'a, C, A> { self._show_only_summary_in_response = Some(new_value); self } @@ -12495,7 +12491,7 @@ impl<'a, C, NC, A> MylibraryAnnotationInsertCall<'a, C, NC, A> where NC: hyper:: /// /// /// ISO-3166-1 code to override the IP-based location. - pub fn country(mut self, new_value: &str) -> MylibraryAnnotationInsertCall<'a, C, NC, A> { + pub fn country(mut self, new_value: &str) -> MylibraryAnnotationInsertCall<'a, C, A> { self._country = Some(new_value.to_string()); self } @@ -12506,7 +12502,7 @@ impl<'a, C, NC, A> MylibraryAnnotationInsertCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryAnnotationInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryAnnotationInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12527,7 +12523,7 @@ impl<'a, C, NC, A> MylibraryAnnotationInsertCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MylibraryAnnotationInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MylibraryAnnotationInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12544,7 +12540,7 @@ impl<'a, C, NC, A> MylibraryAnnotationInsertCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MylibraryAnnotationInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MylibraryAnnotationInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12584,10 +12580,10 @@ impl<'a, C, NC, A> MylibraryAnnotationInsertCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct MylibraryBookshelveRemoveVolumeCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MylibraryBookshelveRemoveVolumeCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _shelf: String, _volume_id: String, _source: Option, @@ -12597,9 +12593,9 @@ pub struct MylibraryBookshelveRemoveVolumeCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MylibraryBookshelveRemoveVolumeCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MylibraryBookshelveRemoveVolumeCall<'a, C, A> {} -impl<'a, C, NC, A> MylibraryBookshelveRemoveVolumeCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MylibraryBookshelveRemoveVolumeCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12727,7 +12723,7 @@ impl<'a, C, NC, A> MylibraryBookshelveRemoveVolumeCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// ID of bookshelf from which to remove a volume. - pub fn shelf(mut self, new_value: &str) -> MylibraryBookshelveRemoveVolumeCall<'a, C, NC, A> { + pub fn shelf(mut self, new_value: &str) -> MylibraryBookshelveRemoveVolumeCall<'a, C, A> { self._shelf = new_value.to_string(); self } @@ -12737,7 +12733,7 @@ impl<'a, C, NC, A> MylibraryBookshelveRemoveVolumeCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// ID of volume to remove. - pub fn volume_id(mut self, new_value: &str) -> MylibraryBookshelveRemoveVolumeCall<'a, C, NC, A> { + pub fn volume_id(mut self, new_value: &str) -> MylibraryBookshelveRemoveVolumeCall<'a, C, A> { self._volume_id = new_value.to_string(); self } @@ -12745,7 +12741,7 @@ impl<'a, C, NC, A> MylibraryBookshelveRemoveVolumeCall<'a, C, NC, A> where NC: h /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> MylibraryBookshelveRemoveVolumeCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> MylibraryBookshelveRemoveVolumeCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -12753,7 +12749,7 @@ impl<'a, C, NC, A> MylibraryBookshelveRemoveVolumeCall<'a, C, NC, A> where NC: h /// /// /// The reason for which the book is removed from the library. - pub fn reason(mut self, new_value: &str) -> MylibraryBookshelveRemoveVolumeCall<'a, C, NC, A> { + pub fn reason(mut self, new_value: &str) -> MylibraryBookshelveRemoveVolumeCall<'a, C, A> { self._reason = Some(new_value.to_string()); self } @@ -12764,7 +12760,7 @@ impl<'a, C, NC, A> MylibraryBookshelveRemoveVolumeCall<'a, C, NC, A> where NC: h /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryBookshelveRemoveVolumeCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryBookshelveRemoveVolumeCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12785,7 +12781,7 @@ impl<'a, C, NC, A> MylibraryBookshelveRemoveVolumeCall<'a, C, NC, A> where NC: h /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MylibraryBookshelveRemoveVolumeCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MylibraryBookshelveRemoveVolumeCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12802,7 +12798,7 @@ impl<'a, C, NC, A> MylibraryBookshelveRemoveVolumeCall<'a, C, NC, A> where NC: h /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MylibraryBookshelveRemoveVolumeCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MylibraryBookshelveRemoveVolumeCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12850,10 +12846,10 @@ impl<'a, C, NC, A> MylibraryBookshelveRemoveVolumeCall<'a, C, NC, A> where NC: h /// .doit(); /// # } /// ``` -pub struct MylibraryAnnotationListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MylibraryAnnotationListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _volume_id: Option, _updated_min: Option, _updated_max: Option, @@ -12869,9 +12865,9 @@ pub struct MylibraryAnnotationListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MylibraryAnnotationListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MylibraryAnnotationListCall<'a, C, A> {} -impl<'a, C, NC, A> MylibraryAnnotationListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MylibraryAnnotationListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13010,7 +13006,7 @@ impl<'a, C, NC, A> MylibraryAnnotationListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// The volume to restrict annotations to. - pub fn volume_id(mut self, new_value: &str) -> MylibraryAnnotationListCall<'a, C, NC, A> { + pub fn volume_id(mut self, new_value: &str) -> MylibraryAnnotationListCall<'a, C, A> { self._volume_id = Some(new_value.to_string()); self } @@ -13018,7 +13014,7 @@ impl<'a, C, NC, A> MylibraryAnnotationListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// RFC 3339 timestamp to restrict to items updated since this timestamp (inclusive). - pub fn updated_min(mut self, new_value: &str) -> MylibraryAnnotationListCall<'a, C, NC, A> { + pub fn updated_min(mut self, new_value: &str) -> MylibraryAnnotationListCall<'a, C, A> { self._updated_min = Some(new_value.to_string()); self } @@ -13026,7 +13022,7 @@ impl<'a, C, NC, A> MylibraryAnnotationListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// RFC 3339 timestamp to restrict to items updated prior to this timestamp (exclusive). - pub fn updated_max(mut self, new_value: &str) -> MylibraryAnnotationListCall<'a, C, NC, A> { + pub fn updated_max(mut self, new_value: &str) -> MylibraryAnnotationListCall<'a, C, A> { self._updated_max = Some(new_value.to_string()); self } @@ -13034,7 +13030,7 @@ impl<'a, C, NC, A> MylibraryAnnotationListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> MylibraryAnnotationListCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> MylibraryAnnotationListCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -13042,7 +13038,7 @@ impl<'a, C, NC, A> MylibraryAnnotationListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// Set to true to return deleted annotations. updatedMin must be in the request to use this. Defaults to false. - pub fn show_deleted(mut self, new_value: bool) -> MylibraryAnnotationListCall<'a, C, NC, A> { + pub fn show_deleted(mut self, new_value: bool) -> MylibraryAnnotationListCall<'a, C, A> { self._show_deleted = Some(new_value); self } @@ -13050,7 +13046,7 @@ impl<'a, C, NC, A> MylibraryAnnotationListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// The value of the nextToken from the previous page. - pub fn page_token(mut self, new_value: &str) -> MylibraryAnnotationListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> MylibraryAnnotationListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -13058,7 +13054,7 @@ impl<'a, C, NC, A> MylibraryAnnotationListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// Maximum number of results to return - pub fn max_results(mut self, new_value: u32) -> MylibraryAnnotationListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> MylibraryAnnotationListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -13067,7 +13063,7 @@ impl<'a, C, NC, A> MylibraryAnnotationListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// The layer ID(s) to limit annotation by. - pub fn add_layer_ids(mut self, new_value: &str) -> MylibraryAnnotationListCall<'a, C, NC, A> { + pub fn add_layer_ids(mut self, new_value: &str) -> MylibraryAnnotationListCall<'a, C, A> { self._layer_ids.push(new_value.to_string()); self } @@ -13075,7 +13071,7 @@ impl<'a, C, NC, A> MylibraryAnnotationListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// The layer ID to limit annotation by. - pub fn layer_id(mut self, new_value: &str) -> MylibraryAnnotationListCall<'a, C, NC, A> { + pub fn layer_id(mut self, new_value: &str) -> MylibraryAnnotationListCall<'a, C, A> { self._layer_id = Some(new_value.to_string()); self } @@ -13083,7 +13079,7 @@ impl<'a, C, NC, A> MylibraryAnnotationListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// The content version for the requested volume. - pub fn content_version(mut self, new_value: &str) -> MylibraryAnnotationListCall<'a, C, NC, A> { + pub fn content_version(mut self, new_value: &str) -> MylibraryAnnotationListCall<'a, C, A> { self._content_version = Some(new_value.to_string()); self } @@ -13094,7 +13090,7 @@ impl<'a, C, NC, A> MylibraryAnnotationListCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryAnnotationListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryAnnotationListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13115,7 +13111,7 @@ impl<'a, C, NC, A> MylibraryAnnotationListCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MylibraryAnnotationListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MylibraryAnnotationListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13132,7 +13128,7 @@ impl<'a, C, NC, A> MylibraryAnnotationListCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MylibraryAnnotationListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MylibraryAnnotationListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13177,10 +13173,10 @@ impl<'a, C, NC, A> MylibraryAnnotationListCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct MylibraryAnnotationUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MylibraryAnnotationUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _request: Annotation, _annotation_id: String, _source: Option, @@ -13189,9 +13185,9 @@ pub struct MylibraryAnnotationUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MylibraryAnnotationUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MylibraryAnnotationUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> MylibraryAnnotationUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MylibraryAnnotationUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13333,7 +13329,7 @@ impl<'a, C, NC, A> MylibraryAnnotationUpdateCall<'a, C, NC, A> where NC: hyper:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Annotation) -> MylibraryAnnotationUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Annotation) -> MylibraryAnnotationUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13343,7 +13339,7 @@ impl<'a, C, NC, A> MylibraryAnnotationUpdateCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The ID for the annotation to update. - pub fn annotation_id(mut self, new_value: &str) -> MylibraryAnnotationUpdateCall<'a, C, NC, A> { + pub fn annotation_id(mut self, new_value: &str) -> MylibraryAnnotationUpdateCall<'a, C, A> { self._annotation_id = new_value.to_string(); self } @@ -13351,7 +13347,7 @@ impl<'a, C, NC, A> MylibraryAnnotationUpdateCall<'a, C, NC, A> where NC: hyper:: /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> MylibraryAnnotationUpdateCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> MylibraryAnnotationUpdateCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -13362,7 +13358,7 @@ impl<'a, C, NC, A> MylibraryAnnotationUpdateCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryAnnotationUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryAnnotationUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13383,7 +13379,7 @@ impl<'a, C, NC, A> MylibraryAnnotationUpdateCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MylibraryAnnotationUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MylibraryAnnotationUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13400,7 +13396,7 @@ impl<'a, C, NC, A> MylibraryAnnotationUpdateCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MylibraryAnnotationUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MylibraryAnnotationUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13442,10 +13438,10 @@ impl<'a, C, NC, A> MylibraryAnnotationUpdateCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct MylibraryReadingpositionSetPositionCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MylibraryReadingpositionSetPositionCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _volume_id: String, _timestamp: String, _position: String, @@ -13458,9 +13454,9 @@ pub struct MylibraryReadingpositionSetPositionCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MylibraryReadingpositionSetPositionCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MylibraryReadingpositionSetPositionCall<'a, C, A> {} -impl<'a, C, NC, A> MylibraryReadingpositionSetPositionCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MylibraryReadingpositionSetPositionCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13595,7 +13591,7 @@ impl<'a, C, NC, A> MylibraryReadingpositionSetPositionCall<'a, C, NC, A> where N /// we provide this method for API completeness. /// /// ID of volume for which to update the reading position. - pub fn volume_id(mut self, new_value: &str) -> MylibraryReadingpositionSetPositionCall<'a, C, NC, A> { + pub fn volume_id(mut self, new_value: &str) -> MylibraryReadingpositionSetPositionCall<'a, C, A> { self._volume_id = new_value.to_string(); self } @@ -13605,7 +13601,7 @@ impl<'a, C, NC, A> MylibraryReadingpositionSetPositionCall<'a, C, NC, A> where N /// we provide this method for API completeness. /// /// RFC 3339 UTC format timestamp associated with this reading position. - pub fn timestamp(mut self, new_value: &str) -> MylibraryReadingpositionSetPositionCall<'a, C, NC, A> { + pub fn timestamp(mut self, new_value: &str) -> MylibraryReadingpositionSetPositionCall<'a, C, A> { self._timestamp = new_value.to_string(); self } @@ -13615,7 +13611,7 @@ impl<'a, C, NC, A> MylibraryReadingpositionSetPositionCall<'a, C, NC, A> where N /// we provide this method for API completeness. /// /// Position string for the new volume reading position. - pub fn position(mut self, new_value: &str) -> MylibraryReadingpositionSetPositionCall<'a, C, NC, A> { + pub fn position(mut self, new_value: &str) -> MylibraryReadingpositionSetPositionCall<'a, C, A> { self._position = new_value.to_string(); self } @@ -13623,7 +13619,7 @@ impl<'a, C, NC, A> MylibraryReadingpositionSetPositionCall<'a, C, NC, A> where N /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> MylibraryReadingpositionSetPositionCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> MylibraryReadingpositionSetPositionCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -13631,7 +13627,7 @@ impl<'a, C, NC, A> MylibraryReadingpositionSetPositionCall<'a, C, NC, A> where N /// /// /// Random persistent device cookie optional on set position. - pub fn device_cookie(mut self, new_value: &str) -> MylibraryReadingpositionSetPositionCall<'a, C, NC, A> { + pub fn device_cookie(mut self, new_value: &str) -> MylibraryReadingpositionSetPositionCall<'a, C, A> { self._device_cookie = Some(new_value.to_string()); self } @@ -13639,7 +13635,7 @@ impl<'a, C, NC, A> MylibraryReadingpositionSetPositionCall<'a, C, NC, A> where N /// /// /// Volume content version for which this reading position applies. - pub fn content_version(mut self, new_value: &str) -> MylibraryReadingpositionSetPositionCall<'a, C, NC, A> { + pub fn content_version(mut self, new_value: &str) -> MylibraryReadingpositionSetPositionCall<'a, C, A> { self._content_version = Some(new_value.to_string()); self } @@ -13647,7 +13643,7 @@ impl<'a, C, NC, A> MylibraryReadingpositionSetPositionCall<'a, C, NC, A> where N /// /// /// Action that caused this reading position to be set. - pub fn action(mut self, new_value: &str) -> MylibraryReadingpositionSetPositionCall<'a, C, NC, A> { + pub fn action(mut self, new_value: &str) -> MylibraryReadingpositionSetPositionCall<'a, C, A> { self._action = Some(new_value.to_string()); self } @@ -13658,7 +13654,7 @@ impl<'a, C, NC, A> MylibraryReadingpositionSetPositionCall<'a, C, NC, A> where N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryReadingpositionSetPositionCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryReadingpositionSetPositionCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13679,7 +13675,7 @@ impl<'a, C, NC, A> MylibraryReadingpositionSetPositionCall<'a, C, NC, A> where N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MylibraryReadingpositionSetPositionCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MylibraryReadingpositionSetPositionCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13696,7 +13692,7 @@ impl<'a, C, NC, A> MylibraryReadingpositionSetPositionCall<'a, C, NC, A> where N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MylibraryReadingpositionSetPositionCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MylibraryReadingpositionSetPositionCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13735,10 +13731,10 @@ impl<'a, C, NC, A> MylibraryReadingpositionSetPositionCall<'a, C, NC, A> where N /// .doit(); /// # } /// ``` -pub struct MylibraryBookshelveGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MylibraryBookshelveGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _shelf: String, _source: Option, _delegate: Option<&'a mut Delegate>, @@ -13746,9 +13742,9 @@ pub struct MylibraryBookshelveGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MylibraryBookshelveGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MylibraryBookshelveGetCall<'a, C, A> {} -impl<'a, C, NC, A> MylibraryBookshelveGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MylibraryBookshelveGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13883,7 +13879,7 @@ impl<'a, C, NC, A> MylibraryBookshelveGetCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// ID of bookshelf to retrieve. - pub fn shelf(mut self, new_value: &str) -> MylibraryBookshelveGetCall<'a, C, NC, A> { + pub fn shelf(mut self, new_value: &str) -> MylibraryBookshelveGetCall<'a, C, A> { self._shelf = new_value.to_string(); self } @@ -13891,7 +13887,7 @@ impl<'a, C, NC, A> MylibraryBookshelveGetCall<'a, C, NC, A> where NC: hyper::net /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> MylibraryBookshelveGetCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> MylibraryBookshelveGetCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -13902,7 +13898,7 @@ impl<'a, C, NC, A> MylibraryBookshelveGetCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryBookshelveGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryBookshelveGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13923,7 +13919,7 @@ impl<'a, C, NC, A> MylibraryBookshelveGetCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MylibraryBookshelveGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MylibraryBookshelveGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13940,7 +13936,7 @@ impl<'a, C, NC, A> MylibraryBookshelveGetCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MylibraryBookshelveGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MylibraryBookshelveGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13979,19 +13975,19 @@ impl<'a, C, NC, A> MylibraryBookshelveGetCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct MylibraryBookshelveListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MylibraryBookshelveListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _source: Option, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MylibraryBookshelveListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MylibraryBookshelveListCall<'a, C, A> {} -impl<'a, C, NC, A> MylibraryBookshelveListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MylibraryBookshelveListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14099,7 +14095,7 @@ impl<'a, C, NC, A> MylibraryBookshelveListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> MylibraryBookshelveListCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> MylibraryBookshelveListCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -14110,7 +14106,7 @@ impl<'a, C, NC, A> MylibraryBookshelveListCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryBookshelveListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryBookshelveListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14131,7 +14127,7 @@ impl<'a, C, NC, A> MylibraryBookshelveListCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MylibraryBookshelveListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MylibraryBookshelveListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14148,7 +14144,7 @@ impl<'a, C, NC, A> MylibraryBookshelveListCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MylibraryBookshelveListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MylibraryBookshelveListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14188,10 +14184,10 @@ impl<'a, C, NC, A> MylibraryBookshelveListCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct MylibraryReadingpositionGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MylibraryReadingpositionGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _volume_id: String, _source: Option, _content_version: Option, @@ -14200,9 +14196,9 @@ pub struct MylibraryReadingpositionGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MylibraryReadingpositionGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MylibraryReadingpositionGetCall<'a, C, A> {} -impl<'a, C, NC, A> MylibraryReadingpositionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MylibraryReadingpositionGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14340,7 +14336,7 @@ impl<'a, C, NC, A> MylibraryReadingpositionGetCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// ID of volume for which to retrieve a reading position. - pub fn volume_id(mut self, new_value: &str) -> MylibraryReadingpositionGetCall<'a, C, NC, A> { + pub fn volume_id(mut self, new_value: &str) -> MylibraryReadingpositionGetCall<'a, C, A> { self._volume_id = new_value.to_string(); self } @@ -14348,7 +14344,7 @@ impl<'a, C, NC, A> MylibraryReadingpositionGetCall<'a, C, NC, A> where NC: hyper /// /// /// String to identify the originator of this request. - pub fn source(mut self, new_value: &str) -> MylibraryReadingpositionGetCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> MylibraryReadingpositionGetCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -14356,7 +14352,7 @@ impl<'a, C, NC, A> MylibraryReadingpositionGetCall<'a, C, NC, A> where NC: hyper /// /// /// Volume content version for which this reading position is requested. - pub fn content_version(mut self, new_value: &str) -> MylibraryReadingpositionGetCall<'a, C, NC, A> { + pub fn content_version(mut self, new_value: &str) -> MylibraryReadingpositionGetCall<'a, C, A> { self._content_version = Some(new_value.to_string()); self } @@ -14367,7 +14363,7 @@ impl<'a, C, NC, A> MylibraryReadingpositionGetCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryReadingpositionGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MylibraryReadingpositionGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14388,7 +14384,7 @@ impl<'a, C, NC, A> MylibraryReadingpositionGetCall<'a, C, NC, A> where NC: hyper /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MylibraryReadingpositionGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MylibraryReadingpositionGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14405,7 +14401,7 @@ impl<'a, C, NC, A> MylibraryReadingpositionGetCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MylibraryReadingpositionGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MylibraryReadingpositionGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14447,10 +14443,10 @@ impl<'a, C, NC, A> MylibraryReadingpositionGetCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct CloudloadingAddBookCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CloudloadingAddBookCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _upload_client_token: Option, _name: Option, _mime_type: Option, @@ -14460,9 +14456,9 @@ pub struct CloudloadingAddBookCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CloudloadingAddBookCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CloudloadingAddBookCall<'a, C, A> {} -impl<'a, C, NC, A> CloudloadingAddBookCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CloudloadingAddBookCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14578,7 +14574,7 @@ impl<'a, C, NC, A> CloudloadingAddBookCall<'a, C, NC, A> where NC: hyper::net::N /// Sets the *upload_client_token* query property to the given value. /// /// - pub fn upload_client_token(mut self, new_value: &str) -> CloudloadingAddBookCall<'a, C, NC, A> { + pub fn upload_client_token(mut self, new_value: &str) -> CloudloadingAddBookCall<'a, C, A> { self._upload_client_token = Some(new_value.to_string()); self } @@ -14586,7 +14582,7 @@ impl<'a, C, NC, A> CloudloadingAddBookCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The document name. It can be set only if the drive_document_id is set. - pub fn name(mut self, new_value: &str) -> CloudloadingAddBookCall<'a, C, NC, A> { + pub fn name(mut self, new_value: &str) -> CloudloadingAddBookCall<'a, C, A> { self._name = Some(new_value.to_string()); self } @@ -14594,7 +14590,7 @@ impl<'a, C, NC, A> CloudloadingAddBookCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The document MIME type. It can be set only if the drive_document_id is set. - pub fn mime_type(mut self, new_value: &str) -> CloudloadingAddBookCall<'a, C, NC, A> { + pub fn mime_type(mut self, new_value: &str) -> CloudloadingAddBookCall<'a, C, A> { self._mime_type = Some(new_value.to_string()); self } @@ -14602,7 +14598,7 @@ impl<'a, C, NC, A> CloudloadingAddBookCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// A drive document id. The upload_client_token must not be set. - pub fn drive_document_id(mut self, new_value: &str) -> CloudloadingAddBookCall<'a, C, NC, A> { + pub fn drive_document_id(mut self, new_value: &str) -> CloudloadingAddBookCall<'a, C, A> { self._drive_document_id = Some(new_value.to_string()); self } @@ -14613,7 +14609,7 @@ impl<'a, C, NC, A> CloudloadingAddBookCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CloudloadingAddBookCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CloudloadingAddBookCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14634,7 +14630,7 @@ impl<'a, C, NC, A> CloudloadingAddBookCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CloudloadingAddBookCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CloudloadingAddBookCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14651,7 +14647,7 @@ impl<'a, C, NC, A> CloudloadingAddBookCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CloudloadingAddBookCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CloudloadingAddBookCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14695,19 +14691,19 @@ impl<'a, C, NC, A> CloudloadingAddBookCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct CloudloadingUpdateBookCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CloudloadingUpdateBookCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _request: BooksCloudloadingResource, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CloudloadingUpdateBookCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CloudloadingUpdateBookCall<'a, C, A> {} -impl<'a, C, NC, A> CloudloadingUpdateBookCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CloudloadingUpdateBookCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14821,7 +14817,7 @@ impl<'a, C, NC, A> CloudloadingUpdateBookCall<'a, C, NC, A> where NC: hyper::net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &BooksCloudloadingResource) -> CloudloadingUpdateBookCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &BooksCloudloadingResource) -> CloudloadingUpdateBookCall<'a, C, A> { self._request = new_value.clone(); self } @@ -14832,7 +14828,7 @@ impl<'a, C, NC, A> CloudloadingUpdateBookCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CloudloadingUpdateBookCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CloudloadingUpdateBookCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14853,7 +14849,7 @@ impl<'a, C, NC, A> CloudloadingUpdateBookCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CloudloadingUpdateBookCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CloudloadingUpdateBookCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14870,7 +14866,7 @@ impl<'a, C, NC, A> CloudloadingUpdateBookCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CloudloadingUpdateBookCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CloudloadingUpdateBookCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14908,19 +14904,19 @@ impl<'a, C, NC, A> CloudloadingUpdateBookCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct CloudloadingDeleteBookCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CloudloadingDeleteBookCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Books, + hub: &'a Books, _volume_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CloudloadingDeleteBookCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CloudloadingDeleteBookCall<'a, C, A> {} -impl<'a, C, NC, A> CloudloadingDeleteBookCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CloudloadingDeleteBookCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15017,7 +15013,7 @@ impl<'a, C, NC, A> CloudloadingDeleteBookCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The id of the book to be removed. - pub fn volume_id(mut self, new_value: &str) -> CloudloadingDeleteBookCall<'a, C, NC, A> { + pub fn volume_id(mut self, new_value: &str) -> CloudloadingDeleteBookCall<'a, C, A> { self._volume_id = new_value.to_string(); self } @@ -15028,7 +15024,7 @@ impl<'a, C, NC, A> CloudloadingDeleteBookCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CloudloadingDeleteBookCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CloudloadingDeleteBookCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15049,7 +15045,7 @@ impl<'a, C, NC, A> CloudloadingDeleteBookCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CloudloadingDeleteBookCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CloudloadingDeleteBookCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15066,7 +15062,7 @@ impl<'a, C, NC, A> CloudloadingDeleteBookCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CloudloadingDeleteBookCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CloudloadingDeleteBookCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/calendar3/Cargo.toml b/gen/calendar3/Cargo.toml index c1157585da2..b6146c28b1e 100644 --- a/gen/calendar3/Cargo.toml +++ b/gen/calendar3/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-calendar3" -version = "0.1.4+20150303" +version = "0.1.5+20150303" authors = ["Sebastian Thiel "] description = "A complete library to interact with calendar (protocol v3)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/calendar3" homepage = "https://developers.google.com/google-apps/calendar/firstapp" -documentation = "http://byron.github.io/google-apis-rs/google-calendar3" +documentation = "http://byron.github.io/google-apis-rs/google_calendar3" license = "MIT" keywords = ["calendar", "google", "protocol", "web", "api"] diff --git a/gen/calendar3/README.md b/gen/calendar3/README.md index 72a759e504c..cec60509ba6 100644 --- a/gen/calendar3/README.md +++ b/gen/calendar3/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-calendar3` library allows access to all features of the *Google calendar* service. -This documentation was generated from *calendar* crate version *0.1.4+20150303*, where *20150303* is the exact revision of the *calendar:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *calendar* crate version *0.1.5+20150303*, where *20150303* is the exact revision of the *calendar:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *calendar* *v3* API can be found at the [official documentation site](https://developers.google.com/google-apps/calendar/firstapp). diff --git a/gen/calendar3/src/cmn.rs b/gen/calendar3/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/calendar3/src/cmn.rs +++ b/gen/calendar3/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/calendar3/src/lib.rs b/gen/calendar3/src/lib.rs index 3073cb0f7d8..528a027030a 100644 --- a/gen/calendar3/src/lib.rs +++ b/gen/calendar3/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *calendar* crate version *0.1.4+20150303*, where *20150303* is the exact revision of the *calendar:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *calendar* crate version *0.1.5+20150303*, where *20150303* is the exact revision of the *calendar:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *calendar* *v3* API can be found at the //! [official documentation site](https://developers.google.com/google-apps/calendar/firstapp). @@ -247,7 +247,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -365,55 +364,52 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct CalendarHub { +pub struct CalendarHub { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for CalendarHub {} +impl<'a, C, A> Hub for CalendarHub {} -impl<'a, C, NC, A> CalendarHub - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CalendarHub + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> CalendarHub { + pub fn new(client: C, authenticator: A) -> CalendarHub { CalendarHub { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn acl(&'a self) -> AclMethods<'a, C, NC, A> { + pub fn acl(&'a self) -> AclMethods<'a, C, A> { AclMethods { hub: &self } } - pub fn calendar_list(&'a self) -> CalendarListMethods<'a, C, NC, A> { + pub fn calendar_list(&'a self) -> CalendarListMethods<'a, C, A> { CalendarListMethods { hub: &self } } - pub fn calendars(&'a self) -> CalendarMethods<'a, C, NC, A> { + pub fn calendars(&'a self) -> CalendarMethods<'a, C, A> { CalendarMethods { hub: &self } } - pub fn channels(&'a self) -> ChannelMethods<'a, C, NC, A> { + pub fn channels(&'a self) -> ChannelMethods<'a, C, A> { ChannelMethods { hub: &self } } - pub fn colors(&'a self) -> ColorMethods<'a, C, NC, A> { + pub fn colors(&'a self) -> ColorMethods<'a, C, A> { ColorMethods { hub: &self } } - pub fn events(&'a self) -> EventMethods<'a, C, NC, A> { + pub fn events(&'a self) -> EventMethods<'a, C, A> { EventMethods { hub: &self } } - pub fn freebusy(&'a self) -> FreebusyMethods<'a, C, NC, A> { + pub fn freebusy(&'a self) -> FreebusyMethods<'a, C, A> { FreebusyMethods { hub: &self } } - pub fn settings(&'a self) -> SettingMethods<'a, C, NC, A> { + pub fn settings(&'a self) -> SettingMethods<'a, C, A> { SettingMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -1368,15 +1364,15 @@ impl ResponseResult for Event {} /// let rb = hub.freebusy(); /// # } /// ``` -pub struct FreebusyMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FreebusyMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, } -impl<'a, C, NC, A> MethodsBuilder for FreebusyMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for FreebusyMethods<'a, C, A> {} -impl<'a, C, NC, A> FreebusyMethods<'a, C, NC, A> { +impl<'a, C, A> FreebusyMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1385,7 +1381,7 @@ impl<'a, C, NC, A> FreebusyMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn query(&self, request: &FreeBusyRequest) -> FreebusyQueryCall<'a, C, NC, A> { + pub fn query(&self, request: &FreeBusyRequest) -> FreebusyQueryCall<'a, C, A> { FreebusyQueryCall { hub: self.hub, _request: request.clone(), @@ -1426,20 +1422,20 @@ impl<'a, C, NC, A> FreebusyMethods<'a, C, NC, A> { /// let rb = hub.settings(); /// # } /// ``` -pub struct SettingMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SettingMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, } -impl<'a, C, NC, A> MethodsBuilder for SettingMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for SettingMethods<'a, C, A> {} -impl<'a, C, NC, A> SettingMethods<'a, C, NC, A> { +impl<'a, C, A> SettingMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Returns all user settings for the authenticated user. - pub fn list(&self) -> SettingListCall<'a, C, NC, A> { + pub fn list(&self) -> SettingListCall<'a, C, A> { SettingListCall { hub: self.hub, _sync_token: Default::default(), @@ -1458,7 +1454,7 @@ impl<'a, C, NC, A> SettingMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn watch(&self, request: &Channel) -> SettingWatchCall<'a, C, NC, A> { + pub fn watch(&self, request: &Channel) -> SettingWatchCall<'a, C, A> { SettingWatchCall { hub: self.hub, _request: request.clone(), @@ -1478,7 +1474,7 @@ impl<'a, C, NC, A> SettingMethods<'a, C, NC, A> { /// # Arguments /// /// * `setting` - The id of the user setting. - pub fn get(&self, setting: &str) -> SettingGetCall<'a, C, NC, A> { + pub fn get(&self, setting: &str) -> SettingGetCall<'a, C, A> { SettingGetCall { hub: self.hub, _setting: setting.to_string(), @@ -1519,15 +1515,15 @@ impl<'a, C, NC, A> SettingMethods<'a, C, NC, A> { /// let rb = hub.calendar_list(); /// # } /// ``` -pub struct CalendarListMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CalendarListMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, } -impl<'a, C, NC, A> MethodsBuilder for CalendarListMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CalendarListMethods<'a, C, A> {} -impl<'a, C, NC, A> CalendarListMethods<'a, C, NC, A> { +impl<'a, C, A> CalendarListMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1537,7 +1533,7 @@ impl<'a, C, NC, A> CalendarListMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `calendarId` - Calendar identifier. - pub fn update(&self, request: &CalendarListEntry, calendar_id: &str) -> CalendarListUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &CalendarListEntry, calendar_id: &str) -> CalendarListUpdateCall<'a, C, A> { CalendarListUpdateCall { hub: self.hub, _request: request.clone(), @@ -1556,7 +1552,7 @@ impl<'a, C, NC, A> CalendarListMethods<'a, C, NC, A> { /// # Arguments /// /// * `calendarId` - Calendar identifier. - pub fn delete(&self, calendar_id: &str) -> CalendarListDeleteCall<'a, C, NC, A> { + pub fn delete(&self, calendar_id: &str) -> CalendarListDeleteCall<'a, C, A> { CalendarListDeleteCall { hub: self.hub, _calendar_id: calendar_id.to_string(), @@ -1573,7 +1569,7 @@ impl<'a, C, NC, A> CalendarListMethods<'a, C, NC, A> { /// # Arguments /// /// * `calendarId` - Calendar identifier. - pub fn get(&self, calendar_id: &str) -> CalendarListGetCall<'a, C, NC, A> { + pub fn get(&self, calendar_id: &str) -> CalendarListGetCall<'a, C, A> { CalendarListGetCall { hub: self.hub, _calendar_id: calendar_id.to_string(), @@ -1586,7 +1582,7 @@ impl<'a, C, NC, A> CalendarListMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Returns entries on the user's calendar list. - pub fn list(&self) -> CalendarListListCall<'a, C, NC, A> { + pub fn list(&self) -> CalendarListListCall<'a, C, A> { CalendarListListCall { hub: self.hub, _sync_token: Default::default(), @@ -1608,7 +1604,7 @@ impl<'a, C, NC, A> CalendarListMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &CalendarListEntry) -> CalendarListInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &CalendarListEntry) -> CalendarListInsertCall<'a, C, A> { CalendarListInsertCall { hub: self.hub, _request: request.clone(), @@ -1627,7 +1623,7 @@ impl<'a, C, NC, A> CalendarListMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `calendarId` - Calendar identifier. - pub fn patch(&self, request: &CalendarListEntry, calendar_id: &str) -> CalendarListPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &CalendarListEntry, calendar_id: &str) -> CalendarListPatchCall<'a, C, A> { CalendarListPatchCall { hub: self.hub, _request: request.clone(), @@ -1646,7 +1642,7 @@ impl<'a, C, NC, A> CalendarListMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn watch(&self, request: &Channel) -> CalendarListWatchCall<'a, C, NC, A> { + pub fn watch(&self, request: &Channel) -> CalendarListWatchCall<'a, C, A> { CalendarListWatchCall { hub: self.hub, _request: request.clone(), @@ -1693,15 +1689,15 @@ impl<'a, C, NC, A> CalendarListMethods<'a, C, NC, A> { /// let rb = hub.calendars(); /// # } /// ``` -pub struct CalendarMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CalendarMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, } -impl<'a, C, NC, A> MethodsBuilder for CalendarMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CalendarMethods<'a, C, A> {} -impl<'a, C, NC, A> CalendarMethods<'a, C, NC, A> { +impl<'a, C, A> CalendarMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1711,7 +1707,7 @@ impl<'a, C, NC, A> CalendarMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `calendarId` - Calendar identifier. - pub fn patch(&self, request: &Calendar, calendar_id: &str) -> CalendarPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Calendar, calendar_id: &str) -> CalendarPatchCall<'a, C, A> { CalendarPatchCall { hub: self.hub, _request: request.clone(), @@ -1729,7 +1725,7 @@ impl<'a, C, NC, A> CalendarMethods<'a, C, NC, A> { /// # Arguments /// /// * `calendarId` - Calendar identifier. - pub fn delete(&self, calendar_id: &str) -> CalendarDeleteCall<'a, C, NC, A> { + pub fn delete(&self, calendar_id: &str) -> CalendarDeleteCall<'a, C, A> { CalendarDeleteCall { hub: self.hub, _calendar_id: calendar_id.to_string(), @@ -1746,7 +1742,7 @@ impl<'a, C, NC, A> CalendarMethods<'a, C, NC, A> { /// # Arguments /// /// * `calendarId` - Calendar identifier. - pub fn get(&self, calendar_id: &str) -> CalendarGetCall<'a, C, NC, A> { + pub fn get(&self, calendar_id: &str) -> CalendarGetCall<'a, C, A> { CalendarGetCall { hub: self.hub, _calendar_id: calendar_id.to_string(), @@ -1763,7 +1759,7 @@ impl<'a, C, NC, A> CalendarMethods<'a, C, NC, A> { /// # Arguments /// /// * `calendarId` - Calendar identifier. - pub fn clear(&self, calendar_id: &str) -> CalendarClearCall<'a, C, NC, A> { + pub fn clear(&self, calendar_id: &str) -> CalendarClearCall<'a, C, A> { CalendarClearCall { hub: self.hub, _calendar_id: calendar_id.to_string(), @@ -1780,7 +1776,7 @@ impl<'a, C, NC, A> CalendarMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &Calendar) -> CalendarInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Calendar) -> CalendarInsertCall<'a, C, A> { CalendarInsertCall { hub: self.hub, _request: request.clone(), @@ -1798,7 +1794,7 @@ impl<'a, C, NC, A> CalendarMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `calendarId` - Calendar identifier. - pub fn update(&self, request: &Calendar, calendar_id: &str) -> CalendarUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Calendar, calendar_id: &str) -> CalendarUpdateCall<'a, C, A> { CalendarUpdateCall { hub: self.hub, _request: request.clone(), @@ -1840,15 +1836,15 @@ impl<'a, C, NC, A> CalendarMethods<'a, C, NC, A> { /// let rb = hub.acl(); /// # } /// ``` -pub struct AclMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AclMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, } -impl<'a, C, NC, A> MethodsBuilder for AclMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AclMethods<'a, C, A> {} -impl<'a, C, NC, A> AclMethods<'a, C, NC, A> { +impl<'a, C, A> AclMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1858,7 +1854,7 @@ impl<'a, C, NC, A> AclMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `calendarId` - Calendar identifier. - pub fn watch(&self, request: &Channel, calendar_id: &str) -> AclWatchCall<'a, C, NC, A> { + pub fn watch(&self, request: &Channel, calendar_id: &str) -> AclWatchCall<'a, C, A> { AclWatchCall { hub: self.hub, _request: request.clone(), @@ -1881,7 +1877,7 @@ impl<'a, C, NC, A> AclMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `calendarId` - Calendar identifier. - pub fn insert(&self, request: &AclRule, calendar_id: &str) -> AclInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &AclRule, calendar_id: &str) -> AclInsertCall<'a, C, A> { AclInsertCall { hub: self.hub, _request: request.clone(), @@ -1901,7 +1897,7 @@ impl<'a, C, NC, A> AclMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `calendarId` - Calendar identifier. /// * `ruleId` - ACL rule identifier. - pub fn update(&self, request: &AclRule, calendar_id: &str, rule_id: &str) -> AclUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &AclRule, calendar_id: &str, rule_id: &str) -> AclUpdateCall<'a, C, A> { AclUpdateCall { hub: self.hub, _request: request.clone(), @@ -1922,7 +1918,7 @@ impl<'a, C, NC, A> AclMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `calendarId` - Calendar identifier. /// * `ruleId` - ACL rule identifier. - pub fn patch(&self, request: &AclRule, calendar_id: &str, rule_id: &str) -> AclPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &AclRule, calendar_id: &str, rule_id: &str) -> AclPatchCall<'a, C, A> { AclPatchCall { hub: self.hub, _request: request.clone(), @@ -1941,7 +1937,7 @@ impl<'a, C, NC, A> AclMethods<'a, C, NC, A> { /// # Arguments /// /// * `calendarId` - Calendar identifier. - pub fn list(&self, calendar_id: &str) -> AclListCall<'a, C, NC, A> { + pub fn list(&self, calendar_id: &str) -> AclListCall<'a, C, A> { AclListCall { hub: self.hub, _calendar_id: calendar_id.to_string(), @@ -1963,7 +1959,7 @@ impl<'a, C, NC, A> AclMethods<'a, C, NC, A> { /// /// * `calendarId` - Calendar identifier. /// * `ruleId` - ACL rule identifier. - pub fn delete(&self, calendar_id: &str, rule_id: &str) -> AclDeleteCall<'a, C, NC, A> { + pub fn delete(&self, calendar_id: &str, rule_id: &str) -> AclDeleteCall<'a, C, A> { AclDeleteCall { hub: self.hub, _calendar_id: calendar_id.to_string(), @@ -1982,7 +1978,7 @@ impl<'a, C, NC, A> AclMethods<'a, C, NC, A> { /// /// * `calendarId` - Calendar identifier. /// * `ruleId` - ACL rule identifier. - pub fn get(&self, calendar_id: &str, rule_id: &str) -> AclGetCall<'a, C, NC, A> { + pub fn get(&self, calendar_id: &str, rule_id: &str) -> AclGetCall<'a, C, A> { AclGetCall { hub: self.hub, _calendar_id: calendar_id.to_string(), @@ -2024,15 +2020,15 @@ impl<'a, C, NC, A> AclMethods<'a, C, NC, A> { /// let rb = hub.channels(); /// # } /// ``` -pub struct ChannelMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChannelMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, } -impl<'a, C, NC, A> MethodsBuilder for ChannelMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ChannelMethods<'a, C, A> {} -impl<'a, C, NC, A> ChannelMethods<'a, C, NC, A> { +impl<'a, C, A> ChannelMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2041,7 +2037,7 @@ impl<'a, C, NC, A> ChannelMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn stop(&self, request: &Channel) -> ChannelStopCall<'a, C, NC, A> { + pub fn stop(&self, request: &Channel) -> ChannelStopCall<'a, C, A> { ChannelStopCall { hub: self.hub, _request: request.clone(), @@ -2082,20 +2078,20 @@ impl<'a, C, NC, A> ChannelMethods<'a, C, NC, A> { /// let rb = hub.colors(); /// # } /// ``` -pub struct ColorMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ColorMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, } -impl<'a, C, NC, A> MethodsBuilder for ColorMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ColorMethods<'a, C, A> {} -impl<'a, C, NC, A> ColorMethods<'a, C, NC, A> { +impl<'a, C, A> ColorMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Returns the color definitions for calendars and events. - pub fn get(&self) -> ColorGetCall<'a, C, NC, A> { + pub fn get(&self) -> ColorGetCall<'a, C, A> { ColorGetCall { hub: self.hub, _delegate: Default::default(), @@ -2135,15 +2131,15 @@ impl<'a, C, NC, A> ColorMethods<'a, C, NC, A> { /// let rb = hub.events(); /// # } /// ``` -pub struct EventMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, } -impl<'a, C, NC, A> MethodsBuilder for EventMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for EventMethods<'a, C, A> {} -impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { +impl<'a, C, A> EventMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2153,7 +2149,7 @@ impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { /// /// * `calendarId` - Calendar identifier. /// * `eventId` - Event identifier. - pub fn delete(&self, calendar_id: &str, event_id: &str) -> EventDeleteCall<'a, C, NC, A> { + pub fn delete(&self, calendar_id: &str, event_id: &str) -> EventDeleteCall<'a, C, A> { EventDeleteCall { hub: self.hub, _calendar_id: calendar_id.to_string(), @@ -2173,7 +2169,7 @@ impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `calendarId` - Calendar identifier. - pub fn insert(&self, request: &Event, calendar_id: &str) -> EventInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Event, calendar_id: &str) -> EventInsertCall<'a, C, A> { EventInsertCall { hub: self.hub, _request: request.clone(), @@ -2194,7 +2190,7 @@ impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `calendarId` - Calendar identifier. - pub fn import(&self, request: &Event, calendar_id: &str) -> EventImportCall<'a, C, NC, A> { + pub fn import(&self, request: &Event, calendar_id: &str) -> EventImportCall<'a, C, A> { EventImportCall { hub: self.hub, _request: request.clone(), @@ -2213,7 +2209,7 @@ impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { /// /// * `calendarId` - Calendar identifier. /// * `eventId` - Recurring event identifier. - pub fn instances(&self, calendar_id: &str, event_id: &str) -> EventInstanceCall<'a, C, NC, A> { + pub fn instances(&self, calendar_id: &str, event_id: &str) -> EventInstanceCall<'a, C, A> { EventInstanceCall { hub: self.hub, _calendar_id: calendar_id.to_string(), @@ -2241,7 +2237,7 @@ impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { /// /// * `calendarId` - Calendar identifier. /// * `eventId` - Event identifier. - pub fn get(&self, calendar_id: &str, event_id: &str) -> EventGetCall<'a, C, NC, A> { + pub fn get(&self, calendar_id: &str, event_id: &str) -> EventGetCall<'a, C, A> { EventGetCall { hub: self.hub, _calendar_id: calendar_id.to_string(), @@ -2262,7 +2258,7 @@ impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { /// # Arguments /// /// * `calendarId` - Calendar identifier. - pub fn list(&self, calendar_id: &str) -> EventListCall<'a, C, NC, A> { + pub fn list(&self, calendar_id: &str) -> EventListCall<'a, C, A> { EventListCall { hub: self.hub, _calendar_id: calendar_id.to_string(), @@ -2298,7 +2294,7 @@ impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `calendarId` - Calendar identifier. /// * `eventId` - Event identifier. - pub fn patch(&self, request: &Event, calendar_id: &str, event_id: &str) -> EventPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Event, calendar_id: &str, event_id: &str) -> EventPatchCall<'a, C, A> { EventPatchCall { hub: self.hub, _request: request.clone(), @@ -2322,7 +2318,7 @@ impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { /// * `calendarId` - Calendar identifier of the source calendar where the event currently is on. /// * `eventId` - Event identifier. /// * `destination` - Calendar identifier of the target calendar where the event is to be moved to. - pub fn move_(&self, calendar_id: &str, event_id: &str, destination: &str) -> EventMoveCall<'a, C, NC, A> { + pub fn move_(&self, calendar_id: &str, event_id: &str, destination: &str) -> EventMoveCall<'a, C, A> { EventMoveCall { hub: self.hub, _calendar_id: calendar_id.to_string(), @@ -2344,7 +2340,7 @@ impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `calendarId` - Calendar identifier. /// * `eventId` - Event identifier. - pub fn update(&self, request: &Event, calendar_id: &str, event_id: &str) -> EventUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Event, calendar_id: &str, event_id: &str) -> EventUpdateCall<'a, C, A> { EventUpdateCall { hub: self.hub, _request: request.clone(), @@ -2367,7 +2363,7 @@ impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `calendarId` - Calendar identifier. - pub fn watch(&self, request: &Channel, calendar_id: &str) -> EventWatchCall<'a, C, NC, A> { + pub fn watch(&self, request: &Channel, calendar_id: &str) -> EventWatchCall<'a, C, A> { EventWatchCall { hub: self.hub, _request: request.clone(), @@ -2403,7 +2399,7 @@ impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { /// /// * `calendarId` - Calendar identifier. /// * `text` - The text describing the event to be created. - pub fn quick_add(&self, calendar_id: &str, text: &str) -> EventQuickAddCall<'a, C, NC, A> { + pub fn quick_add(&self, calendar_id: &str, text: &str) -> EventQuickAddCall<'a, C, A> { EventQuickAddCall { hub: self.hub, _calendar_id: calendar_id.to_string(), @@ -2460,19 +2456,19 @@ impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct FreebusyQueryCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FreebusyQueryCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _request: FreeBusyRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FreebusyQueryCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FreebusyQueryCall<'a, C, A> {} -impl<'a, C, NC, A> FreebusyQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FreebusyQueryCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2586,7 +2582,7 @@ impl<'a, C, NC, A> FreebusyQueryCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &FreeBusyRequest) -> FreebusyQueryCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &FreeBusyRequest) -> FreebusyQueryCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2597,7 +2593,7 @@ impl<'a, C, NC, A> FreebusyQueryCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FreebusyQueryCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FreebusyQueryCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2618,7 +2614,7 @@ impl<'a, C, NC, A> FreebusyQueryCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FreebusyQueryCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FreebusyQueryCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2635,7 +2631,7 @@ impl<'a, C, NC, A> FreebusyQueryCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FreebusyQueryCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FreebusyQueryCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2676,10 +2672,10 @@ impl<'a, C, NC, A> FreebusyQueryCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct SettingListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SettingListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _sync_token: Option, _page_token: Option, _max_results: Option, @@ -2688,9 +2684,9 @@ pub struct SettingListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SettingListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SettingListCall<'a, C, A> {} -impl<'a, C, NC, A> SettingListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SettingListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2807,7 +2803,7 @@ impl<'a, C, NC, A> SettingListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// If the syncToken expires, the server will respond with a 410 GONE response code and the client should clear its storage and perform a full synchronization without any syncToken. /// Learn more about incremental synchronization. /// Optional. The default is to return all entries. - pub fn sync_token(mut self, new_value: &str) -> SettingListCall<'a, C, NC, A> { + pub fn sync_token(mut self, new_value: &str) -> SettingListCall<'a, C, A> { self._sync_token = Some(new_value.to_string()); self } @@ -2815,7 +2811,7 @@ impl<'a, C, NC, A> SettingListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Token specifying which result page to return. Optional. - pub fn page_token(mut self, new_value: &str) -> SettingListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> SettingListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2823,7 +2819,7 @@ impl<'a, C, NC, A> SettingListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Maximum number of entries returned on one result page. By default the value is 100 entries. The page size can never be larger than 250 entries. Optional. - pub fn max_results(mut self, new_value: i32) -> SettingListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> SettingListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2834,7 +2830,7 @@ impl<'a, C, NC, A> SettingListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SettingListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SettingListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2855,7 +2851,7 @@ impl<'a, C, NC, A> SettingListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SettingListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SettingListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2872,7 +2868,7 @@ impl<'a, C, NC, A> SettingListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SettingListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SettingListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2919,10 +2915,10 @@ impl<'a, C, NC, A> SettingListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct SettingWatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SettingWatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _request: Channel, _sync_token: Option, _page_token: Option, @@ -2932,9 +2928,9 @@ pub struct SettingWatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SettingWatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SettingWatchCall<'a, C, A> {} -impl<'a, C, NC, A> SettingWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SettingWatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3057,7 +3053,7 @@ impl<'a, C, NC, A> SettingWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Channel) -> SettingWatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Channel) -> SettingWatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3068,7 +3064,7 @@ impl<'a, C, NC, A> SettingWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// If the syncToken expires, the server will respond with a 410 GONE response code and the client should clear its storage and perform a full synchronization without any syncToken. /// Learn more about incremental synchronization. /// Optional. The default is to return all entries. - pub fn sync_token(mut self, new_value: &str) -> SettingWatchCall<'a, C, NC, A> { + pub fn sync_token(mut self, new_value: &str) -> SettingWatchCall<'a, C, A> { self._sync_token = Some(new_value.to_string()); self } @@ -3076,7 +3072,7 @@ impl<'a, C, NC, A> SettingWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Token specifying which result page to return. Optional. - pub fn page_token(mut self, new_value: &str) -> SettingWatchCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> SettingWatchCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -3084,7 +3080,7 @@ impl<'a, C, NC, A> SettingWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Maximum number of entries returned on one result page. By default the value is 100 entries. The page size can never be larger than 250 entries. Optional. - pub fn max_results(mut self, new_value: i32) -> SettingWatchCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> SettingWatchCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -3095,7 +3091,7 @@ impl<'a, C, NC, A> SettingWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SettingWatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SettingWatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3116,7 +3112,7 @@ impl<'a, C, NC, A> SettingWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SettingWatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SettingWatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3133,7 +3129,7 @@ impl<'a, C, NC, A> SettingWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SettingWatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SettingWatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3171,19 +3167,19 @@ impl<'a, C, NC, A> SettingWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct SettingGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SettingGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _setting: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SettingGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SettingGetCall<'a, C, A> {} -impl<'a, C, NC, A> SettingGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SettingGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3315,7 +3311,7 @@ impl<'a, C, NC, A> SettingGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The id of the user setting. - pub fn setting(mut self, new_value: &str) -> SettingGetCall<'a, C, NC, A> { + pub fn setting(mut self, new_value: &str) -> SettingGetCall<'a, C, A> { self._setting = new_value.to_string(); self } @@ -3326,7 +3322,7 @@ impl<'a, C, NC, A> SettingGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SettingGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SettingGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3347,7 +3343,7 @@ impl<'a, C, NC, A> SettingGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SettingGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SettingGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3364,7 +3360,7 @@ impl<'a, C, NC, A> SettingGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SettingGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SettingGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3409,10 +3405,10 @@ impl<'a, C, NC, A> SettingGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct CalendarListUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CalendarListUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _request: CalendarListEntry, _calendar_id: String, _color_rgb_format: Option, @@ -3421,9 +3417,9 @@ pub struct CalendarListUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CalendarListUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CalendarListUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> CalendarListUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CalendarListUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3565,7 +3561,7 @@ impl<'a, C, NC, A> CalendarListUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CalendarListEntry) -> CalendarListUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CalendarListEntry) -> CalendarListUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3575,7 +3571,7 @@ impl<'a, C, NC, A> CalendarListUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> CalendarListUpdateCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> CalendarListUpdateCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -3583,7 +3579,7 @@ impl<'a, C, NC, A> CalendarListUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Whether to use the foregroundColor and backgroundColor fields to write the calendar colors (RGB). If this feature is used, the index-based colorId field will be set to the best matching option automatically. Optional. The default is False. - pub fn color_rgb_format(mut self, new_value: bool) -> CalendarListUpdateCall<'a, C, NC, A> { + pub fn color_rgb_format(mut self, new_value: bool) -> CalendarListUpdateCall<'a, C, A> { self._color_rgb_format = Some(new_value); self } @@ -3594,7 +3590,7 @@ impl<'a, C, NC, A> CalendarListUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarListUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarListUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3615,7 +3611,7 @@ impl<'a, C, NC, A> CalendarListUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CalendarListUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CalendarListUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3632,7 +3628,7 @@ impl<'a, C, NC, A> CalendarListUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CalendarListUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CalendarListUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3670,19 +3666,19 @@ impl<'a, C, NC, A> CalendarListUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct CalendarListDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CalendarListDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _calendar_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CalendarListDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CalendarListDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> CalendarListDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CalendarListDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3803,7 +3799,7 @@ impl<'a, C, NC, A> CalendarListDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> CalendarListDeleteCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> CalendarListDeleteCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -3814,7 +3810,7 @@ impl<'a, C, NC, A> CalendarListDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarListDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarListDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3835,7 +3831,7 @@ impl<'a, C, NC, A> CalendarListDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CalendarListDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CalendarListDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3852,7 +3848,7 @@ impl<'a, C, NC, A> CalendarListDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CalendarListDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CalendarListDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3890,19 +3886,19 @@ impl<'a, C, NC, A> CalendarListDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct CalendarListGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CalendarListGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _calendar_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CalendarListGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CalendarListGetCall<'a, C, A> {} -impl<'a, C, NC, A> CalendarListGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CalendarListGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4034,7 +4030,7 @@ impl<'a, C, NC, A> CalendarListGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> CalendarListGetCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> CalendarListGetCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -4045,7 +4041,7 @@ impl<'a, C, NC, A> CalendarListGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarListGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarListGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4066,7 +4062,7 @@ impl<'a, C, NC, A> CalendarListGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CalendarListGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CalendarListGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4083,7 +4079,7 @@ impl<'a, C, NC, A> CalendarListGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CalendarListGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CalendarListGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4127,10 +4123,10 @@ impl<'a, C, NC, A> CalendarListGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct CalendarListListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CalendarListListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _sync_token: Option, _show_hidden: Option, _show_deleted: Option, @@ -4142,9 +4138,9 @@ pub struct CalendarListListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CalendarListListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CalendarListListCall<'a, C, A> {} -impl<'a, C, NC, A> CalendarListListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CalendarListListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4271,7 +4267,7 @@ impl<'a, C, NC, A> CalendarListListCall<'a, C, NC, A> where NC: hyper::net::Netw /// If the syncToken expires, the server will respond with a 410 GONE response code and the client should clear its storage and perform a full synchronization without any syncToken. /// Learn more about incremental synchronization. /// Optional. The default is to return all entries. - pub fn sync_token(mut self, new_value: &str) -> CalendarListListCall<'a, C, NC, A> { + pub fn sync_token(mut self, new_value: &str) -> CalendarListListCall<'a, C, A> { self._sync_token = Some(new_value.to_string()); self } @@ -4279,7 +4275,7 @@ impl<'a, C, NC, A> CalendarListListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Whether to show hidden entries. Optional. The default is False. - pub fn show_hidden(mut self, new_value: bool) -> CalendarListListCall<'a, C, NC, A> { + pub fn show_hidden(mut self, new_value: bool) -> CalendarListListCall<'a, C, A> { self._show_hidden = Some(new_value); self } @@ -4287,7 +4283,7 @@ impl<'a, C, NC, A> CalendarListListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Whether to include deleted calendar list entries in the result. Optional. The default is False. - pub fn show_deleted(mut self, new_value: bool) -> CalendarListListCall<'a, C, NC, A> { + pub fn show_deleted(mut self, new_value: bool) -> CalendarListListCall<'a, C, A> { self._show_deleted = Some(new_value); self } @@ -4295,7 +4291,7 @@ impl<'a, C, NC, A> CalendarListListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Token specifying which result page to return. Optional. - pub fn page_token(mut self, new_value: &str) -> CalendarListListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> CalendarListListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -4303,7 +4299,7 @@ impl<'a, C, NC, A> CalendarListListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The minimum access role for the user in the returned entires. Optional. The default is no restriction. - pub fn min_access_role(mut self, new_value: &str) -> CalendarListListCall<'a, C, NC, A> { + pub fn min_access_role(mut self, new_value: &str) -> CalendarListListCall<'a, C, A> { self._min_access_role = Some(new_value.to_string()); self } @@ -4311,7 +4307,7 @@ impl<'a, C, NC, A> CalendarListListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Maximum number of entries returned on one result page. By default the value is 100 entries. The page size can never be larger than 250 entries. Optional. - pub fn max_results(mut self, new_value: i32) -> CalendarListListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> CalendarListListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -4322,7 +4318,7 @@ impl<'a, C, NC, A> CalendarListListCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarListListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarListListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4343,7 +4339,7 @@ impl<'a, C, NC, A> CalendarListListCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CalendarListListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CalendarListListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4360,7 +4356,7 @@ impl<'a, C, NC, A> CalendarListListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CalendarListListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CalendarListListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4405,10 +4401,10 @@ impl<'a, C, NC, A> CalendarListListCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct CalendarListInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CalendarListInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _request: CalendarListEntry, _color_rgb_format: Option, _delegate: Option<&'a mut Delegate>, @@ -4416,9 +4412,9 @@ pub struct CalendarListInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CalendarListInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CalendarListInsertCall<'a, C, A> {} -impl<'a, C, NC, A> CalendarListInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CalendarListInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4535,7 +4531,7 @@ impl<'a, C, NC, A> CalendarListInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CalendarListEntry) -> CalendarListInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CalendarListEntry) -> CalendarListInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4543,7 +4539,7 @@ impl<'a, C, NC, A> CalendarListInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Whether to use the foregroundColor and backgroundColor fields to write the calendar colors (RGB). If this feature is used, the index-based colorId field will be set to the best matching option automatically. Optional. The default is False. - pub fn color_rgb_format(mut self, new_value: bool) -> CalendarListInsertCall<'a, C, NC, A> { + pub fn color_rgb_format(mut self, new_value: bool) -> CalendarListInsertCall<'a, C, A> { self._color_rgb_format = Some(new_value); self } @@ -4554,7 +4550,7 @@ impl<'a, C, NC, A> CalendarListInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarListInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarListInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4575,7 +4571,7 @@ impl<'a, C, NC, A> CalendarListInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CalendarListInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CalendarListInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4592,7 +4588,7 @@ impl<'a, C, NC, A> CalendarListInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CalendarListInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CalendarListInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4637,10 +4633,10 @@ impl<'a, C, NC, A> CalendarListInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct CalendarListPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CalendarListPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _request: CalendarListEntry, _calendar_id: String, _color_rgb_format: Option, @@ -4649,9 +4645,9 @@ pub struct CalendarListPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CalendarListPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CalendarListPatchCall<'a, C, A> {} -impl<'a, C, NC, A> CalendarListPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CalendarListPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4793,7 +4789,7 @@ impl<'a, C, NC, A> CalendarListPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CalendarListEntry) -> CalendarListPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CalendarListEntry) -> CalendarListPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4803,7 +4799,7 @@ impl<'a, C, NC, A> CalendarListPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> CalendarListPatchCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> CalendarListPatchCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -4811,7 +4807,7 @@ impl<'a, C, NC, A> CalendarListPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Whether to use the foregroundColor and backgroundColor fields to write the calendar colors (RGB). If this feature is used, the index-based colorId field will be set to the best matching option automatically. Optional. The default is False. - pub fn color_rgb_format(mut self, new_value: bool) -> CalendarListPatchCall<'a, C, NC, A> { + pub fn color_rgb_format(mut self, new_value: bool) -> CalendarListPatchCall<'a, C, A> { self._color_rgb_format = Some(new_value); self } @@ -4822,7 +4818,7 @@ impl<'a, C, NC, A> CalendarListPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarListPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarListPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4843,7 +4839,7 @@ impl<'a, C, NC, A> CalendarListPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CalendarListPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CalendarListPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4860,7 +4856,7 @@ impl<'a, C, NC, A> CalendarListPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CalendarListPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CalendarListPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4910,10 +4906,10 @@ impl<'a, C, NC, A> CalendarListPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct CalendarListWatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CalendarListWatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _request: Channel, _sync_token: Option, _show_hidden: Option, @@ -4926,9 +4922,9 @@ pub struct CalendarListWatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CalendarListWatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CalendarListWatchCall<'a, C, A> {} -impl<'a, C, NC, A> CalendarListWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CalendarListWatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5060,7 +5056,7 @@ impl<'a, C, NC, A> CalendarListWatchCall<'a, C, NC, A> where NC: hyper::net::Net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Channel) -> CalendarListWatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Channel) -> CalendarListWatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5072,7 +5068,7 @@ impl<'a, C, NC, A> CalendarListWatchCall<'a, C, NC, A> where NC: hyper::net::Net /// If the syncToken expires, the server will respond with a 410 GONE response code and the client should clear its storage and perform a full synchronization without any syncToken. /// Learn more about incremental synchronization. /// Optional. The default is to return all entries. - pub fn sync_token(mut self, new_value: &str) -> CalendarListWatchCall<'a, C, NC, A> { + pub fn sync_token(mut self, new_value: &str) -> CalendarListWatchCall<'a, C, A> { self._sync_token = Some(new_value.to_string()); self } @@ -5080,7 +5076,7 @@ impl<'a, C, NC, A> CalendarListWatchCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Whether to show hidden entries. Optional. The default is False. - pub fn show_hidden(mut self, new_value: bool) -> CalendarListWatchCall<'a, C, NC, A> { + pub fn show_hidden(mut self, new_value: bool) -> CalendarListWatchCall<'a, C, A> { self._show_hidden = Some(new_value); self } @@ -5088,7 +5084,7 @@ impl<'a, C, NC, A> CalendarListWatchCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Whether to include deleted calendar list entries in the result. Optional. The default is False. - pub fn show_deleted(mut self, new_value: bool) -> CalendarListWatchCall<'a, C, NC, A> { + pub fn show_deleted(mut self, new_value: bool) -> CalendarListWatchCall<'a, C, A> { self._show_deleted = Some(new_value); self } @@ -5096,7 +5092,7 @@ impl<'a, C, NC, A> CalendarListWatchCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Token specifying which result page to return. Optional. - pub fn page_token(mut self, new_value: &str) -> CalendarListWatchCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> CalendarListWatchCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -5104,7 +5100,7 @@ impl<'a, C, NC, A> CalendarListWatchCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The minimum access role for the user in the returned entires. Optional. The default is no restriction. - pub fn min_access_role(mut self, new_value: &str) -> CalendarListWatchCall<'a, C, NC, A> { + pub fn min_access_role(mut self, new_value: &str) -> CalendarListWatchCall<'a, C, A> { self._min_access_role = Some(new_value.to_string()); self } @@ -5112,7 +5108,7 @@ impl<'a, C, NC, A> CalendarListWatchCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Maximum number of entries returned on one result page. By default the value is 100 entries. The page size can never be larger than 250 entries. Optional. - pub fn max_results(mut self, new_value: i32) -> CalendarListWatchCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> CalendarListWatchCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -5123,7 +5119,7 @@ impl<'a, C, NC, A> CalendarListWatchCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarListWatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarListWatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5144,7 +5140,7 @@ impl<'a, C, NC, A> CalendarListWatchCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CalendarListWatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CalendarListWatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5161,7 +5157,7 @@ impl<'a, C, NC, A> CalendarListWatchCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CalendarListWatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CalendarListWatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5205,10 +5201,10 @@ impl<'a, C, NC, A> CalendarListWatchCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct CalendarPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CalendarPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _request: Calendar, _calendar_id: String, _delegate: Option<&'a mut Delegate>, @@ -5216,9 +5212,9 @@ pub struct CalendarPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CalendarPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CalendarPatchCall<'a, C, A> {} -impl<'a, C, NC, A> CalendarPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CalendarPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5357,7 +5353,7 @@ impl<'a, C, NC, A> CalendarPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Calendar) -> CalendarPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Calendar) -> CalendarPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5367,7 +5363,7 @@ impl<'a, C, NC, A> CalendarPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> CalendarPatchCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> CalendarPatchCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -5378,7 +5374,7 @@ impl<'a, C, NC, A> CalendarPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5399,7 +5395,7 @@ impl<'a, C, NC, A> CalendarPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CalendarPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CalendarPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5416,7 +5412,7 @@ impl<'a, C, NC, A> CalendarPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CalendarPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CalendarPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5454,19 +5450,19 @@ impl<'a, C, NC, A> CalendarPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct CalendarDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CalendarDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _calendar_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CalendarDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CalendarDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> CalendarDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CalendarDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5587,7 +5583,7 @@ impl<'a, C, NC, A> CalendarDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> CalendarDeleteCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> CalendarDeleteCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -5598,7 +5594,7 @@ impl<'a, C, NC, A> CalendarDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5619,7 +5615,7 @@ impl<'a, C, NC, A> CalendarDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CalendarDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CalendarDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5636,7 +5632,7 @@ impl<'a, C, NC, A> CalendarDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CalendarDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CalendarDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5674,19 +5670,19 @@ impl<'a, C, NC, A> CalendarDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct CalendarGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CalendarGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _calendar_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CalendarGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CalendarGetCall<'a, C, A> {} -impl<'a, C, NC, A> CalendarGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CalendarGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5818,7 +5814,7 @@ impl<'a, C, NC, A> CalendarGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> CalendarGetCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> CalendarGetCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -5829,7 +5825,7 @@ impl<'a, C, NC, A> CalendarGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5850,7 +5846,7 @@ impl<'a, C, NC, A> CalendarGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CalendarGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CalendarGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5867,7 +5863,7 @@ impl<'a, C, NC, A> CalendarGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CalendarGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CalendarGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5905,19 +5901,19 @@ impl<'a, C, NC, A> CalendarGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct CalendarClearCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CalendarClearCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _calendar_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CalendarClearCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CalendarClearCall<'a, C, A> {} -impl<'a, C, NC, A> CalendarClearCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CalendarClearCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6038,7 +6034,7 @@ impl<'a, C, NC, A> CalendarClearCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> CalendarClearCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> CalendarClearCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -6049,7 +6045,7 @@ impl<'a, C, NC, A> CalendarClearCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarClearCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarClearCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6070,7 +6066,7 @@ impl<'a, C, NC, A> CalendarClearCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CalendarClearCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CalendarClearCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6087,7 +6083,7 @@ impl<'a, C, NC, A> CalendarClearCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CalendarClearCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CalendarClearCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6131,19 +6127,19 @@ impl<'a, C, NC, A> CalendarClearCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct CalendarInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CalendarInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _request: Calendar, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CalendarInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CalendarInsertCall<'a, C, A> {} -impl<'a, C, NC, A> CalendarInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CalendarInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6257,7 +6253,7 @@ impl<'a, C, NC, A> CalendarInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Calendar) -> CalendarInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Calendar) -> CalendarInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6268,7 +6264,7 @@ impl<'a, C, NC, A> CalendarInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6289,7 +6285,7 @@ impl<'a, C, NC, A> CalendarInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CalendarInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CalendarInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6306,7 +6302,7 @@ impl<'a, C, NC, A> CalendarInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CalendarInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CalendarInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6350,10 +6346,10 @@ impl<'a, C, NC, A> CalendarInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct CalendarUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CalendarUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _request: Calendar, _calendar_id: String, _delegate: Option<&'a mut Delegate>, @@ -6361,9 +6357,9 @@ pub struct CalendarUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CalendarUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CalendarUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> CalendarUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CalendarUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6502,7 +6498,7 @@ impl<'a, C, NC, A> CalendarUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Calendar) -> CalendarUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Calendar) -> CalendarUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6512,7 +6508,7 @@ impl<'a, C, NC, A> CalendarUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> CalendarUpdateCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> CalendarUpdateCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -6523,7 +6519,7 @@ impl<'a, C, NC, A> CalendarUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CalendarUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6544,7 +6540,7 @@ impl<'a, C, NC, A> CalendarUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CalendarUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CalendarUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6561,7 +6557,7 @@ impl<'a, C, NC, A> CalendarUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CalendarUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CalendarUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6609,10 +6605,10 @@ impl<'a, C, NC, A> CalendarUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct AclWatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AclWatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _request: Channel, _calendar_id: String, _sync_token: Option, @@ -6624,9 +6620,9 @@ pub struct AclWatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AclWatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AclWatchCall<'a, C, A> {} -impl<'a, C, NC, A> AclWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AclWatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6777,7 +6773,7 @@ impl<'a, C, NC, A> AclWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Channel) -> AclWatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Channel) -> AclWatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6787,7 +6783,7 @@ impl<'a, C, NC, A> AclWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> AclWatchCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> AclWatchCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -6798,7 +6794,7 @@ impl<'a, C, NC, A> AclWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// If the syncToken expires, the server will respond with a 410 GONE response code and the client should clear its storage and perform a full synchronization without any syncToken. /// Learn more about incremental synchronization. /// Optional. The default is to return all entries. - pub fn sync_token(mut self, new_value: &str) -> AclWatchCall<'a, C, NC, A> { + pub fn sync_token(mut self, new_value: &str) -> AclWatchCall<'a, C, A> { self._sync_token = Some(new_value.to_string()); self } @@ -6806,7 +6802,7 @@ impl<'a, C, NC, A> AclWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Whether to include deleted ACLs in the result. Deleted ACLs are represented by role equal to "none". Deleted ACLs will always be included if syncToken is provided. Optional. The default is False. - pub fn show_deleted(mut self, new_value: bool) -> AclWatchCall<'a, C, NC, A> { + pub fn show_deleted(mut self, new_value: bool) -> AclWatchCall<'a, C, A> { self._show_deleted = Some(new_value); self } @@ -6814,7 +6810,7 @@ impl<'a, C, NC, A> AclWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Token specifying which result page to return. Optional. - pub fn page_token(mut self, new_value: &str) -> AclWatchCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AclWatchCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -6822,7 +6818,7 @@ impl<'a, C, NC, A> AclWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Maximum number of entries returned on one result page. By default the value is 100 entries. The page size can never be larger than 250 entries. Optional. - pub fn max_results(mut self, new_value: i32) -> AclWatchCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AclWatchCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -6833,7 +6829,7 @@ impl<'a, C, NC, A> AclWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AclWatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AclWatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6854,7 +6850,7 @@ impl<'a, C, NC, A> AclWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AclWatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AclWatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6871,7 +6867,7 @@ impl<'a, C, NC, A> AclWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AclWatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AclWatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6915,10 +6911,10 @@ impl<'a, C, NC, A> AclWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct AclInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AclInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _request: AclRule, _calendar_id: String, _delegate: Option<&'a mut Delegate>, @@ -6926,9 +6922,9 @@ pub struct AclInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AclInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AclInsertCall<'a, C, A> {} -impl<'a, C, NC, A> AclInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AclInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7067,7 +7063,7 @@ impl<'a, C, NC, A> AclInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AclRule) -> AclInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AclRule) -> AclInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7077,7 +7073,7 @@ impl<'a, C, NC, A> AclInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> AclInsertCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> AclInsertCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -7088,7 +7084,7 @@ impl<'a, C, NC, A> AclInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AclInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AclInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7109,7 +7105,7 @@ impl<'a, C, NC, A> AclInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AclInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AclInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7126,7 +7122,7 @@ impl<'a, C, NC, A> AclInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AclInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AclInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7170,10 +7166,10 @@ impl<'a, C, NC, A> AclInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct AclUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AclUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _request: AclRule, _calendar_id: String, _rule_id: String, @@ -7182,9 +7178,9 @@ pub struct AclUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AclUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AclUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AclUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AclUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7324,7 +7320,7 @@ impl<'a, C, NC, A> AclUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AclRule) -> AclUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AclRule) -> AclUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7334,7 +7330,7 @@ impl<'a, C, NC, A> AclUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> AclUpdateCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> AclUpdateCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -7344,7 +7340,7 @@ impl<'a, C, NC, A> AclUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// ACL rule identifier. - pub fn rule_id(mut self, new_value: &str) -> AclUpdateCall<'a, C, NC, A> { + pub fn rule_id(mut self, new_value: &str) -> AclUpdateCall<'a, C, A> { self._rule_id = new_value.to_string(); self } @@ -7355,7 +7351,7 @@ impl<'a, C, NC, A> AclUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AclUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AclUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7376,7 +7372,7 @@ impl<'a, C, NC, A> AclUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AclUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AclUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7393,7 +7389,7 @@ impl<'a, C, NC, A> AclUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AclUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AclUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7437,10 +7433,10 @@ impl<'a, C, NC, A> AclUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct AclPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AclPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _request: AclRule, _calendar_id: String, _rule_id: String, @@ -7449,9 +7445,9 @@ pub struct AclPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AclPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AclPatchCall<'a, C, A> {} -impl<'a, C, NC, A> AclPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AclPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7591,7 +7587,7 @@ impl<'a, C, NC, A> AclPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AclRule) -> AclPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AclRule) -> AclPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7601,7 +7597,7 @@ impl<'a, C, NC, A> AclPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> AclPatchCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> AclPatchCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -7611,7 +7607,7 @@ impl<'a, C, NC, A> AclPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// ACL rule identifier. - pub fn rule_id(mut self, new_value: &str) -> AclPatchCall<'a, C, NC, A> { + pub fn rule_id(mut self, new_value: &str) -> AclPatchCall<'a, C, A> { self._rule_id = new_value.to_string(); self } @@ -7622,7 +7618,7 @@ impl<'a, C, NC, A> AclPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AclPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AclPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7643,7 +7639,7 @@ impl<'a, C, NC, A> AclPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AclPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AclPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7660,7 +7656,7 @@ impl<'a, C, NC, A> AclPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AclPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AclPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7702,10 +7698,10 @@ impl<'a, C, NC, A> AclPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct AclListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AclListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _calendar_id: String, _sync_token: Option, _show_deleted: Option, @@ -7716,9 +7712,9 @@ pub struct AclListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AclListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AclListCall<'a, C, A> {} -impl<'a, C, NC, A> AclListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AclListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7862,7 +7858,7 @@ impl<'a, C, NC, A> AclListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> AclListCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> AclListCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -7873,7 +7869,7 @@ impl<'a, C, NC, A> AclListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// If the syncToken expires, the server will respond with a 410 GONE response code and the client should clear its storage and perform a full synchronization without any syncToken. /// Learn more about incremental synchronization. /// Optional. The default is to return all entries. - pub fn sync_token(mut self, new_value: &str) -> AclListCall<'a, C, NC, A> { + pub fn sync_token(mut self, new_value: &str) -> AclListCall<'a, C, A> { self._sync_token = Some(new_value.to_string()); self } @@ -7881,7 +7877,7 @@ impl<'a, C, NC, A> AclListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Whether to include deleted ACLs in the result. Deleted ACLs are represented by role equal to "none". Deleted ACLs will always be included if syncToken is provided. Optional. The default is False. - pub fn show_deleted(mut self, new_value: bool) -> AclListCall<'a, C, NC, A> { + pub fn show_deleted(mut self, new_value: bool) -> AclListCall<'a, C, A> { self._show_deleted = Some(new_value); self } @@ -7889,7 +7885,7 @@ impl<'a, C, NC, A> AclListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Token specifying which result page to return. Optional. - pub fn page_token(mut self, new_value: &str) -> AclListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AclListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -7897,7 +7893,7 @@ impl<'a, C, NC, A> AclListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Maximum number of entries returned on one result page. By default the value is 100 entries. The page size can never be larger than 250 entries. Optional. - pub fn max_results(mut self, new_value: i32) -> AclListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AclListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -7908,7 +7904,7 @@ impl<'a, C, NC, A> AclListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AclListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AclListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7929,7 +7925,7 @@ impl<'a, C, NC, A> AclListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AclListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AclListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7946,7 +7942,7 @@ impl<'a, C, NC, A> AclListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AclListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AclListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7984,10 +7980,10 @@ impl<'a, C, NC, A> AclListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct AclDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AclDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _calendar_id: String, _rule_id: String, _delegate: Option<&'a mut Delegate>, @@ -7995,9 +7991,9 @@ pub struct AclDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AclDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AclDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> AclDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AclDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8119,7 +8115,7 @@ impl<'a, C, NC, A> AclDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> AclDeleteCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> AclDeleteCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -8129,7 +8125,7 @@ impl<'a, C, NC, A> AclDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// ACL rule identifier. - pub fn rule_id(mut self, new_value: &str) -> AclDeleteCall<'a, C, NC, A> { + pub fn rule_id(mut self, new_value: &str) -> AclDeleteCall<'a, C, A> { self._rule_id = new_value.to_string(); self } @@ -8140,7 +8136,7 @@ impl<'a, C, NC, A> AclDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AclDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AclDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8161,7 +8157,7 @@ impl<'a, C, NC, A> AclDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AclDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AclDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8178,7 +8174,7 @@ impl<'a, C, NC, A> AclDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AclDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AclDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8216,10 +8212,10 @@ impl<'a, C, NC, A> AclDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct AclGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AclGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _calendar_id: String, _rule_id: String, _delegate: Option<&'a mut Delegate>, @@ -8227,9 +8223,9 @@ pub struct AclGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AclGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AclGetCall<'a, C, A> {} -impl<'a, C, NC, A> AclGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AclGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8362,7 +8358,7 @@ impl<'a, C, NC, A> AclGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> AclGetCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> AclGetCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -8372,7 +8368,7 @@ impl<'a, C, NC, A> AclGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// we provide this method for API completeness. /// /// ACL rule identifier. - pub fn rule_id(mut self, new_value: &str) -> AclGetCall<'a, C, NC, A> { + pub fn rule_id(mut self, new_value: &str) -> AclGetCall<'a, C, A> { self._rule_id = new_value.to_string(); self } @@ -8383,7 +8379,7 @@ impl<'a, C, NC, A> AclGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AclGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AclGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8404,7 +8400,7 @@ impl<'a, C, NC, A> AclGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AclGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AclGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8421,7 +8417,7 @@ impl<'a, C, NC, A> AclGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AclGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AclGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8465,19 +8461,19 @@ impl<'a, C, NC, A> AclGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// .doit(); /// # } /// ``` -pub struct ChannelStopCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChannelStopCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _request: Channel, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChannelStopCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChannelStopCall<'a, C, A> {} -impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChannelStopCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8580,7 +8576,7 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Channel) -> ChannelStopCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Channel) -> ChannelStopCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8591,7 +8587,7 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelStopCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelStopCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8612,7 +8608,7 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChannelStopCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChannelStopCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8629,7 +8625,7 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChannelStopCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChannelStopCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8667,18 +8663,18 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct ColorGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ColorGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ColorGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ColorGetCall<'a, C, A> {} -impl<'a, C, NC, A> ColorGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ColorGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8786,7 +8782,7 @@ impl<'a, C, NC, A> ColorGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ColorGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ColorGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8807,7 +8803,7 @@ impl<'a, C, NC, A> ColorGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ColorGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ColorGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8824,7 +8820,7 @@ impl<'a, C, NC, A> ColorGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ColorGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ColorGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8863,10 +8859,10 @@ impl<'a, C, NC, A> ColorGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct EventDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _calendar_id: String, _event_id: String, _send_notifications: Option, @@ -8875,9 +8871,9 @@ pub struct EventDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> EventDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9002,7 +8998,7 @@ impl<'a, C, NC, A> EventDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> EventDeleteCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> EventDeleteCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -9012,7 +9008,7 @@ impl<'a, C, NC, A> EventDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Event identifier. - pub fn event_id(mut self, new_value: &str) -> EventDeleteCall<'a, C, NC, A> { + pub fn event_id(mut self, new_value: &str) -> EventDeleteCall<'a, C, A> { self._event_id = new_value.to_string(); self } @@ -9020,7 +9016,7 @@ impl<'a, C, NC, A> EventDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Whether to send notifications about the deletion of the event. Optional. The default is False. - pub fn send_notifications(mut self, new_value: bool) -> EventDeleteCall<'a, C, NC, A> { + pub fn send_notifications(mut self, new_value: bool) -> EventDeleteCall<'a, C, A> { self._send_notifications = Some(new_value); self } @@ -9031,7 +9027,7 @@ impl<'a, C, NC, A> EventDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9052,7 +9048,7 @@ impl<'a, C, NC, A> EventDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9069,7 +9065,7 @@ impl<'a, C, NC, A> EventDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9115,10 +9111,10 @@ impl<'a, C, NC, A> EventDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct EventInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _request: Event, _calendar_id: String, _send_notifications: Option, @@ -9128,9 +9124,9 @@ pub struct EventInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventInsertCall<'a, C, A> {} -impl<'a, C, NC, A> EventInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9275,7 +9271,7 @@ impl<'a, C, NC, A> EventInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Event) -> EventInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Event) -> EventInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9285,7 +9281,7 @@ impl<'a, C, NC, A> EventInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> EventInsertCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> EventInsertCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -9293,7 +9289,7 @@ impl<'a, C, NC, A> EventInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Whether to send notifications about the creation of the new event. Optional. The default is False. - pub fn send_notifications(mut self, new_value: bool) -> EventInsertCall<'a, C, NC, A> { + pub fn send_notifications(mut self, new_value: bool) -> EventInsertCall<'a, C, A> { self._send_notifications = Some(new_value); self } @@ -9301,7 +9297,7 @@ impl<'a, C, NC, A> EventInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The maximum number of attendees to include in the response. If there are more than the specified number of attendees, only the participant is returned. Optional. - pub fn max_attendees(mut self, new_value: i32) -> EventInsertCall<'a, C, NC, A> { + pub fn max_attendees(mut self, new_value: i32) -> EventInsertCall<'a, C, A> { self._max_attendees = Some(new_value); self } @@ -9312,7 +9308,7 @@ impl<'a, C, NC, A> EventInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9333,7 +9329,7 @@ impl<'a, C, NC, A> EventInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9350,7 +9346,7 @@ impl<'a, C, NC, A> EventInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9394,10 +9390,10 @@ impl<'a, C, NC, A> EventInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct EventImportCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventImportCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _request: Event, _calendar_id: String, _delegate: Option<&'a mut Delegate>, @@ -9405,9 +9401,9 @@ pub struct EventImportCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventImportCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventImportCall<'a, C, A> {} -impl<'a, C, NC, A> EventImportCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventImportCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9546,7 +9542,7 @@ impl<'a, C, NC, A> EventImportCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Event) -> EventImportCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Event) -> EventImportCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9556,7 +9552,7 @@ impl<'a, C, NC, A> EventImportCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> EventImportCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> EventImportCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -9567,7 +9563,7 @@ impl<'a, C, NC, A> EventImportCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventImportCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventImportCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9588,7 +9584,7 @@ impl<'a, C, NC, A> EventImportCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventImportCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventImportCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9605,7 +9601,7 @@ impl<'a, C, NC, A> EventImportCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventImportCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventImportCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9652,10 +9648,10 @@ impl<'a, C, NC, A> EventImportCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct EventInstanceCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventInstanceCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _calendar_id: String, _event_id: String, _time_zone: Option, @@ -9672,9 +9668,9 @@ pub struct EventInstanceCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventInstanceCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventInstanceCall<'a, C, A> {} -impl<'a, C, NC, A> EventInstanceCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventInstanceCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9834,7 +9830,7 @@ impl<'a, C, NC, A> EventInstanceCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> EventInstanceCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> EventInstanceCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -9844,7 +9840,7 @@ impl<'a, C, NC, A> EventInstanceCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Recurring event identifier. - pub fn event_id(mut self, new_value: &str) -> EventInstanceCall<'a, C, NC, A> { + pub fn event_id(mut self, new_value: &str) -> EventInstanceCall<'a, C, A> { self._event_id = new_value.to_string(); self } @@ -9852,7 +9848,7 @@ impl<'a, C, NC, A> EventInstanceCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Time zone used in the response. Optional. The default is the time zone of the calendar. - pub fn time_zone(mut self, new_value: &str) -> EventInstanceCall<'a, C, NC, A> { + pub fn time_zone(mut self, new_value: &str) -> EventInstanceCall<'a, C, A> { self._time_zone = Some(new_value.to_string()); self } @@ -9860,7 +9856,7 @@ impl<'a, C, NC, A> EventInstanceCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Lower bound (inclusive) for an event's end time to filter by. Optional. The default is not to filter by end time. - pub fn time_min(mut self, new_value: &str) -> EventInstanceCall<'a, C, NC, A> { + pub fn time_min(mut self, new_value: &str) -> EventInstanceCall<'a, C, A> { self._time_min = Some(new_value.to_string()); self } @@ -9868,7 +9864,7 @@ impl<'a, C, NC, A> EventInstanceCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Upper bound (exclusive) for an event's start time to filter by. Optional. The default is not to filter by start time. - pub fn time_max(mut self, new_value: &str) -> EventInstanceCall<'a, C, NC, A> { + pub fn time_max(mut self, new_value: &str) -> EventInstanceCall<'a, C, A> { self._time_max = Some(new_value.to_string()); self } @@ -9876,7 +9872,7 @@ impl<'a, C, NC, A> EventInstanceCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Whether to include deleted events (with status equals "cancelled") in the result. Cancelled instances of recurring events will still be included if singleEvents is False. Optional. The default is False. - pub fn show_deleted(mut self, new_value: bool) -> EventInstanceCall<'a, C, NC, A> { + pub fn show_deleted(mut self, new_value: bool) -> EventInstanceCall<'a, C, A> { self._show_deleted = Some(new_value); self } @@ -9884,7 +9880,7 @@ impl<'a, C, NC, A> EventInstanceCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Token specifying which result page to return. Optional. - pub fn page_token(mut self, new_value: &str) -> EventInstanceCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> EventInstanceCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -9892,7 +9888,7 @@ impl<'a, C, NC, A> EventInstanceCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// The original start time of the instance in the result. Optional. - pub fn original_start(mut self, new_value: &str) -> EventInstanceCall<'a, C, NC, A> { + pub fn original_start(mut self, new_value: &str) -> EventInstanceCall<'a, C, A> { self._original_start = Some(new_value.to_string()); self } @@ -9900,7 +9896,7 @@ impl<'a, C, NC, A> EventInstanceCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Maximum number of events returned on one result page. By default the value is 250 events. The page size can never be larger than 2500 events. Optional. - pub fn max_results(mut self, new_value: i32) -> EventInstanceCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> EventInstanceCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -9908,7 +9904,7 @@ impl<'a, C, NC, A> EventInstanceCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// The maximum number of attendees to include in the response. If there are more than the specified number of attendees, only the participant is returned. Optional. - pub fn max_attendees(mut self, new_value: i32) -> EventInstanceCall<'a, C, NC, A> { + pub fn max_attendees(mut self, new_value: i32) -> EventInstanceCall<'a, C, A> { self._max_attendees = Some(new_value); self } @@ -9916,7 +9912,7 @@ impl<'a, C, NC, A> EventInstanceCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Whether to always include a value in the email field for the organizer, creator and attendees, even if no real email is available (i.e. a generated, non-working value will be provided). The use of this option is discouraged and should only be used by clients which cannot handle the absence of an email address value in the mentioned places. Optional. The default is False. - pub fn always_include_email(mut self, new_value: bool) -> EventInstanceCall<'a, C, NC, A> { + pub fn always_include_email(mut self, new_value: bool) -> EventInstanceCall<'a, C, A> { self._always_include_email = Some(new_value); self } @@ -9927,7 +9923,7 @@ impl<'a, C, NC, A> EventInstanceCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventInstanceCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventInstanceCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9948,7 +9944,7 @@ impl<'a, C, NC, A> EventInstanceCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventInstanceCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventInstanceCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9965,7 +9961,7 @@ impl<'a, C, NC, A> EventInstanceCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventInstanceCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventInstanceCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10006,10 +10002,10 @@ impl<'a, C, NC, A> EventInstanceCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct EventGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _calendar_id: String, _event_id: String, _time_zone: Option, @@ -10020,9 +10016,9 @@ pub struct EventGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventGetCall<'a, C, A> {} -impl<'a, C, NC, A> EventGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10164,7 +10160,7 @@ impl<'a, C, NC, A> EventGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> EventGetCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> EventGetCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -10174,7 +10170,7 @@ impl<'a, C, NC, A> EventGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Event identifier. - pub fn event_id(mut self, new_value: &str) -> EventGetCall<'a, C, NC, A> { + pub fn event_id(mut self, new_value: &str) -> EventGetCall<'a, C, A> { self._event_id = new_value.to_string(); self } @@ -10182,7 +10178,7 @@ impl<'a, C, NC, A> EventGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Time zone used in the response. Optional. The default is the time zone of the calendar. - pub fn time_zone(mut self, new_value: &str) -> EventGetCall<'a, C, NC, A> { + pub fn time_zone(mut self, new_value: &str) -> EventGetCall<'a, C, A> { self._time_zone = Some(new_value.to_string()); self } @@ -10190,7 +10186,7 @@ impl<'a, C, NC, A> EventGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The maximum number of attendees to include in the response. If there are more than the specified number of attendees, only the participant is returned. Optional. - pub fn max_attendees(mut self, new_value: i32) -> EventGetCall<'a, C, NC, A> { + pub fn max_attendees(mut self, new_value: i32) -> EventGetCall<'a, C, A> { self._max_attendees = Some(new_value); self } @@ -10198,7 +10194,7 @@ impl<'a, C, NC, A> EventGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Whether to always include a value in the email field for the organizer, creator and attendees, even if no real email is available (i.e. a generated, non-working value will be provided). The use of this option is discouraged and should only be used by clients which cannot handle the absence of an email address value in the mentioned places. Optional. The default is False. - pub fn always_include_email(mut self, new_value: bool) -> EventGetCall<'a, C, NC, A> { + pub fn always_include_email(mut self, new_value: bool) -> EventGetCall<'a, C, A> { self._always_include_email = Some(new_value); self } @@ -10209,7 +10205,7 @@ impl<'a, C, NC, A> EventGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10230,7 +10226,7 @@ impl<'a, C, NC, A> EventGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10247,7 +10243,7 @@ impl<'a, C, NC, A> EventGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10302,10 +10298,10 @@ impl<'a, C, NC, A> EventGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct EventListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _calendar_id: String, _updated_min: Option, _time_zone: Option, @@ -10329,9 +10325,9 @@ pub struct EventListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventListCall<'a, C, A> {} -impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10522,7 +10518,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -10530,7 +10526,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Lower bound for an event's last modification time (as a RFC 3339 timestamp) to filter by. When specified, entries deleted since this time will always be included regardless of showDeleted. Optional. The default is not to filter by last modification time. - pub fn updated_min(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn updated_min(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._updated_min = Some(new_value.to_string()); self } @@ -10538,7 +10534,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Time zone used in the response. Optional. The default is the time zone of the calendar. - pub fn time_zone(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn time_zone(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._time_zone = Some(new_value.to_string()); self } @@ -10546,7 +10542,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Lower bound (inclusive) for an event's end time to filter by. Optional. The default is not to filter by end time. - pub fn time_min(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn time_min(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._time_min = Some(new_value.to_string()); self } @@ -10554,7 +10550,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Upper bound (exclusive) for an event's start time to filter by. Optional. The default is not to filter by start time. - pub fn time_max(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn time_max(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._time_max = Some(new_value.to_string()); self } @@ -10575,7 +10571,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// - updatedMin If the syncToken expires, the server will respond with a 410 GONE response code and the client should clear its storage and perform a full synchronization without any syncToken. /// Learn more about incremental synchronization. /// Optional. The default is to return all entries. - pub fn sync_token(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn sync_token(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._sync_token = Some(new_value.to_string()); self } @@ -10583,7 +10579,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether to expand recurring events into instances and only return single one-off events and instances of recurring events, but not the underlying recurring events themselves. Optional. The default is False. - pub fn single_events(mut self, new_value: bool) -> EventListCall<'a, C, NC, A> { + pub fn single_events(mut self, new_value: bool) -> EventListCall<'a, C, A> { self._single_events = Some(new_value); self } @@ -10591,7 +10587,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether to include hidden invitations in the result. Optional. The default is False. - pub fn show_hidden_invitations(mut self, new_value: bool) -> EventListCall<'a, C, NC, A> { + pub fn show_hidden_invitations(mut self, new_value: bool) -> EventListCall<'a, C, A> { self._show_hidden_invitations = Some(new_value); self } @@ -10599,7 +10595,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether to include deleted events (with status equals "cancelled") in the result. Cancelled instances of recurring events (but not the underlying recurring event) will still be included if showDeleted and singleEvents are both False. If showDeleted and singleEvents are both True, only single instances of deleted events (but not the underlying recurring events) are returned. Optional. The default is False. - pub fn show_deleted(mut self, new_value: bool) -> EventListCall<'a, C, NC, A> { + pub fn show_deleted(mut self, new_value: bool) -> EventListCall<'a, C, A> { self._show_deleted = Some(new_value); self } @@ -10608,7 +10604,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Extended properties constraint specified as propertyName=value. Matches only shared properties. This parameter might be repeated multiple times to return events that match all given constraints. - pub fn add_shared_extended_property(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn add_shared_extended_property(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._shared_extended_property.push(new_value.to_string()); self } @@ -10616,7 +10612,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Free text search terms to find events that match these terms in any field, except for extended properties. Optional. - pub fn q(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn q(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._q = Some(new_value.to_string()); self } @@ -10625,7 +10621,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Extended properties constraint specified as propertyName=value. Matches only private properties. This parameter might be repeated multiple times to return events that match all given constraints. - pub fn add_private_extended_property(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn add_private_extended_property(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._private_extended_property.push(new_value.to_string()); self } @@ -10633,7 +10629,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Token specifying which result page to return. Optional. - pub fn page_token(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -10641,7 +10637,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The order of the events returned in the result. Optional. The default is an unspecified, stable order. - pub fn order_by(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn order_by(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._order_by = Some(new_value.to_string()); self } @@ -10649,7 +10645,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Maximum number of events returned on one result page. By default the value is 250 events. The page size can never be larger than 2500 events. Optional. - pub fn max_results(mut self, new_value: i32) -> EventListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> EventListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -10657,7 +10653,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The maximum number of attendees to include in the response. If there are more than the specified number of attendees, only the participant is returned. Optional. - pub fn max_attendees(mut self, new_value: i32) -> EventListCall<'a, C, NC, A> { + pub fn max_attendees(mut self, new_value: i32) -> EventListCall<'a, C, A> { self._max_attendees = Some(new_value); self } @@ -10665,7 +10661,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Specifies event ID in the iCalendar format to be included in the response. Optional. - pub fn i_cal_uid(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn i_cal_uid(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._i_cal_uid = Some(new_value.to_string()); self } @@ -10673,7 +10669,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether to always include a value in the email field for the organizer, creator and attendees, even if no real email is available (i.e. a generated, non-working value will be provided). The use of this option is discouraged and should only be used by clients which cannot handle the absence of an email address value in the mentioned places. Optional. The default is False. - pub fn always_include_email(mut self, new_value: bool) -> EventListCall<'a, C, NC, A> { + pub fn always_include_email(mut self, new_value: bool) -> EventListCall<'a, C, A> { self._always_include_email = Some(new_value); self } @@ -10684,7 +10680,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10705,7 +10701,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10722,7 +10718,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10769,10 +10765,10 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct EventPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _request: Event, _calendar_id: String, _event_id: String, @@ -10784,9 +10780,9 @@ pub struct EventPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventPatchCall<'a, C, A> {} -impl<'a, C, NC, A> EventPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10935,7 +10931,7 @@ impl<'a, C, NC, A> EventPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Event) -> EventPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Event) -> EventPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -10945,7 +10941,7 @@ impl<'a, C, NC, A> EventPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> EventPatchCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> EventPatchCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -10955,7 +10951,7 @@ impl<'a, C, NC, A> EventPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Event identifier. - pub fn event_id(mut self, new_value: &str) -> EventPatchCall<'a, C, NC, A> { + pub fn event_id(mut self, new_value: &str) -> EventPatchCall<'a, C, A> { self._event_id = new_value.to_string(); self } @@ -10963,7 +10959,7 @@ impl<'a, C, NC, A> EventPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether to send notifications about the event update (e.g. attendee's responses, title changes, etc.). Optional. The default is False. - pub fn send_notifications(mut self, new_value: bool) -> EventPatchCall<'a, C, NC, A> { + pub fn send_notifications(mut self, new_value: bool) -> EventPatchCall<'a, C, A> { self._send_notifications = Some(new_value); self } @@ -10971,7 +10967,7 @@ impl<'a, C, NC, A> EventPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The maximum number of attendees to include in the response. If there are more than the specified number of attendees, only the participant is returned. Optional. - pub fn max_attendees(mut self, new_value: i32) -> EventPatchCall<'a, C, NC, A> { + pub fn max_attendees(mut self, new_value: i32) -> EventPatchCall<'a, C, A> { self._max_attendees = Some(new_value); self } @@ -10979,7 +10975,7 @@ impl<'a, C, NC, A> EventPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether to always include a value in the email field for the organizer, creator and attendees, even if no real email is available (i.e. a generated, non-working value will be provided). The use of this option is discouraged and should only be used by clients which cannot handle the absence of an email address value in the mentioned places. Optional. The default is False. - pub fn always_include_email(mut self, new_value: bool) -> EventPatchCall<'a, C, NC, A> { + pub fn always_include_email(mut self, new_value: bool) -> EventPatchCall<'a, C, A> { self._always_include_email = Some(new_value); self } @@ -10990,7 +10986,7 @@ impl<'a, C, NC, A> EventPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11011,7 +11007,7 @@ impl<'a, C, NC, A> EventPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11028,7 +11024,7 @@ impl<'a, C, NC, A> EventPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11067,10 +11063,10 @@ impl<'a, C, NC, A> EventPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct EventMoveCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventMoveCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _calendar_id: String, _event_id: String, _destination: String, @@ -11080,9 +11076,9 @@ pub struct EventMoveCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventMoveCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventMoveCall<'a, C, A> {} -impl<'a, C, NC, A> EventMoveCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventMoveCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11219,7 +11215,7 @@ impl<'a, C, NC, A> EventMoveCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Calendar identifier of the source calendar where the event currently is on. - pub fn calendar_id(mut self, new_value: &str) -> EventMoveCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> EventMoveCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -11229,7 +11225,7 @@ impl<'a, C, NC, A> EventMoveCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Event identifier. - pub fn event_id(mut self, new_value: &str) -> EventMoveCall<'a, C, NC, A> { + pub fn event_id(mut self, new_value: &str) -> EventMoveCall<'a, C, A> { self._event_id = new_value.to_string(); self } @@ -11239,7 +11235,7 @@ impl<'a, C, NC, A> EventMoveCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Calendar identifier of the target calendar where the event is to be moved to. - pub fn destination(mut self, new_value: &str) -> EventMoveCall<'a, C, NC, A> { + pub fn destination(mut self, new_value: &str) -> EventMoveCall<'a, C, A> { self._destination = new_value.to_string(); self } @@ -11247,7 +11243,7 @@ impl<'a, C, NC, A> EventMoveCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether to send notifications about the change of the event's organizer. Optional. The default is False. - pub fn send_notifications(mut self, new_value: bool) -> EventMoveCall<'a, C, NC, A> { + pub fn send_notifications(mut self, new_value: bool) -> EventMoveCall<'a, C, A> { self._send_notifications = Some(new_value); self } @@ -11258,7 +11254,7 @@ impl<'a, C, NC, A> EventMoveCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventMoveCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventMoveCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11279,7 +11275,7 @@ impl<'a, C, NC, A> EventMoveCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventMoveCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventMoveCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11296,7 +11292,7 @@ impl<'a, C, NC, A> EventMoveCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventMoveCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventMoveCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11343,10 +11339,10 @@ impl<'a, C, NC, A> EventMoveCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct EventUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _request: Event, _calendar_id: String, _event_id: String, @@ -11358,9 +11354,9 @@ pub struct EventUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> EventUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11509,7 +11505,7 @@ impl<'a, C, NC, A> EventUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Event) -> EventUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Event) -> EventUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -11519,7 +11515,7 @@ impl<'a, C, NC, A> EventUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> EventUpdateCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> EventUpdateCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -11529,7 +11525,7 @@ impl<'a, C, NC, A> EventUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Event identifier. - pub fn event_id(mut self, new_value: &str) -> EventUpdateCall<'a, C, NC, A> { + pub fn event_id(mut self, new_value: &str) -> EventUpdateCall<'a, C, A> { self._event_id = new_value.to_string(); self } @@ -11537,7 +11533,7 @@ impl<'a, C, NC, A> EventUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Whether to send notifications about the event update (e.g. attendee's responses, title changes, etc.). Optional. The default is False. - pub fn send_notifications(mut self, new_value: bool) -> EventUpdateCall<'a, C, NC, A> { + pub fn send_notifications(mut self, new_value: bool) -> EventUpdateCall<'a, C, A> { self._send_notifications = Some(new_value); self } @@ -11545,7 +11541,7 @@ impl<'a, C, NC, A> EventUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The maximum number of attendees to include in the response. If there are more than the specified number of attendees, only the participant is returned. Optional. - pub fn max_attendees(mut self, new_value: i32) -> EventUpdateCall<'a, C, NC, A> { + pub fn max_attendees(mut self, new_value: i32) -> EventUpdateCall<'a, C, A> { self._max_attendees = Some(new_value); self } @@ -11553,7 +11549,7 @@ impl<'a, C, NC, A> EventUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Whether to always include a value in the email field for the organizer, creator and attendees, even if no real email is available (i.e. a generated, non-working value will be provided). The use of this option is discouraged and should only be used by clients which cannot handle the absence of an email address value in the mentioned places. Optional. The default is False. - pub fn always_include_email(mut self, new_value: bool) -> EventUpdateCall<'a, C, NC, A> { + pub fn always_include_email(mut self, new_value: bool) -> EventUpdateCall<'a, C, A> { self._always_include_email = Some(new_value); self } @@ -11564,7 +11560,7 @@ impl<'a, C, NC, A> EventUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11585,7 +11581,7 @@ impl<'a, C, NC, A> EventUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11602,7 +11598,7 @@ impl<'a, C, NC, A> EventUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11663,10 +11659,10 @@ impl<'a, C, NC, A> EventUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct EventWatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventWatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _request: Channel, _calendar_id: String, _updated_min: Option, @@ -11691,9 +11687,9 @@ pub struct EventWatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventWatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventWatchCall<'a, C, A> {} -impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventWatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11891,7 +11887,7 @@ impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Channel) -> EventWatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Channel) -> EventWatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -11901,7 +11897,7 @@ impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> EventWatchCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> EventWatchCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -11909,7 +11905,7 @@ impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Lower bound for an event's last modification time (as a RFC 3339 timestamp) to filter by. When specified, entries deleted since this time will always be included regardless of showDeleted. Optional. The default is not to filter by last modification time. - pub fn updated_min(mut self, new_value: &str) -> EventWatchCall<'a, C, NC, A> { + pub fn updated_min(mut self, new_value: &str) -> EventWatchCall<'a, C, A> { self._updated_min = Some(new_value.to_string()); self } @@ -11917,7 +11913,7 @@ impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Time zone used in the response. Optional. The default is the time zone of the calendar. - pub fn time_zone(mut self, new_value: &str) -> EventWatchCall<'a, C, NC, A> { + pub fn time_zone(mut self, new_value: &str) -> EventWatchCall<'a, C, A> { self._time_zone = Some(new_value.to_string()); self } @@ -11925,7 +11921,7 @@ impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Lower bound (inclusive) for an event's end time to filter by. Optional. The default is not to filter by end time. - pub fn time_min(mut self, new_value: &str) -> EventWatchCall<'a, C, NC, A> { + pub fn time_min(mut self, new_value: &str) -> EventWatchCall<'a, C, A> { self._time_min = Some(new_value.to_string()); self } @@ -11933,7 +11929,7 @@ impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Upper bound (exclusive) for an event's start time to filter by. Optional. The default is not to filter by start time. - pub fn time_max(mut self, new_value: &str) -> EventWatchCall<'a, C, NC, A> { + pub fn time_max(mut self, new_value: &str) -> EventWatchCall<'a, C, A> { self._time_max = Some(new_value.to_string()); self } @@ -11954,7 +11950,7 @@ impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// - updatedMin If the syncToken expires, the server will respond with a 410 GONE response code and the client should clear its storage and perform a full synchronization without any syncToken. /// Learn more about incremental synchronization. /// Optional. The default is to return all entries. - pub fn sync_token(mut self, new_value: &str) -> EventWatchCall<'a, C, NC, A> { + pub fn sync_token(mut self, new_value: &str) -> EventWatchCall<'a, C, A> { self._sync_token = Some(new_value.to_string()); self } @@ -11962,7 +11958,7 @@ impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether to expand recurring events into instances and only return single one-off events and instances of recurring events, but not the underlying recurring events themselves. Optional. The default is False. - pub fn single_events(mut self, new_value: bool) -> EventWatchCall<'a, C, NC, A> { + pub fn single_events(mut self, new_value: bool) -> EventWatchCall<'a, C, A> { self._single_events = Some(new_value); self } @@ -11970,7 +11966,7 @@ impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether to include hidden invitations in the result. Optional. The default is False. - pub fn show_hidden_invitations(mut self, new_value: bool) -> EventWatchCall<'a, C, NC, A> { + pub fn show_hidden_invitations(mut self, new_value: bool) -> EventWatchCall<'a, C, A> { self._show_hidden_invitations = Some(new_value); self } @@ -11978,7 +11974,7 @@ impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether to include deleted events (with status equals "cancelled") in the result. Cancelled instances of recurring events (but not the underlying recurring event) will still be included if showDeleted and singleEvents are both False. If showDeleted and singleEvents are both True, only single instances of deleted events (but not the underlying recurring events) are returned. Optional. The default is False. - pub fn show_deleted(mut self, new_value: bool) -> EventWatchCall<'a, C, NC, A> { + pub fn show_deleted(mut self, new_value: bool) -> EventWatchCall<'a, C, A> { self._show_deleted = Some(new_value); self } @@ -11987,7 +11983,7 @@ impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Extended properties constraint specified as propertyName=value. Matches only shared properties. This parameter might be repeated multiple times to return events that match all given constraints. - pub fn add_shared_extended_property(mut self, new_value: &str) -> EventWatchCall<'a, C, NC, A> { + pub fn add_shared_extended_property(mut self, new_value: &str) -> EventWatchCall<'a, C, A> { self._shared_extended_property.push(new_value.to_string()); self } @@ -11995,7 +11991,7 @@ impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Free text search terms to find events that match these terms in any field, except for extended properties. Optional. - pub fn q(mut self, new_value: &str) -> EventWatchCall<'a, C, NC, A> { + pub fn q(mut self, new_value: &str) -> EventWatchCall<'a, C, A> { self._q = Some(new_value.to_string()); self } @@ -12004,7 +12000,7 @@ impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Extended properties constraint specified as propertyName=value. Matches only private properties. This parameter might be repeated multiple times to return events that match all given constraints. - pub fn add_private_extended_property(mut self, new_value: &str) -> EventWatchCall<'a, C, NC, A> { + pub fn add_private_extended_property(mut self, new_value: &str) -> EventWatchCall<'a, C, A> { self._private_extended_property.push(new_value.to_string()); self } @@ -12012,7 +12008,7 @@ impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Token specifying which result page to return. Optional. - pub fn page_token(mut self, new_value: &str) -> EventWatchCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> EventWatchCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -12020,7 +12016,7 @@ impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The order of the events returned in the result. Optional. The default is an unspecified, stable order. - pub fn order_by(mut self, new_value: &str) -> EventWatchCall<'a, C, NC, A> { + pub fn order_by(mut self, new_value: &str) -> EventWatchCall<'a, C, A> { self._order_by = Some(new_value.to_string()); self } @@ -12028,7 +12024,7 @@ impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Maximum number of events returned on one result page. By default the value is 250 events. The page size can never be larger than 2500 events. Optional. - pub fn max_results(mut self, new_value: i32) -> EventWatchCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> EventWatchCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -12036,7 +12032,7 @@ impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The maximum number of attendees to include in the response. If there are more than the specified number of attendees, only the participant is returned. Optional. - pub fn max_attendees(mut self, new_value: i32) -> EventWatchCall<'a, C, NC, A> { + pub fn max_attendees(mut self, new_value: i32) -> EventWatchCall<'a, C, A> { self._max_attendees = Some(new_value); self } @@ -12044,7 +12040,7 @@ impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Specifies event ID in the iCalendar format to be included in the response. Optional. - pub fn i_cal_uid(mut self, new_value: &str) -> EventWatchCall<'a, C, NC, A> { + pub fn i_cal_uid(mut self, new_value: &str) -> EventWatchCall<'a, C, A> { self._i_cal_uid = Some(new_value.to_string()); self } @@ -12052,7 +12048,7 @@ impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether to always include a value in the email field for the organizer, creator and attendees, even if no real email is available (i.e. a generated, non-working value will be provided). The use of this option is discouraged and should only be used by clients which cannot handle the absence of an email address value in the mentioned places. Optional. The default is False. - pub fn always_include_email(mut self, new_value: bool) -> EventWatchCall<'a, C, NC, A> { + pub fn always_include_email(mut self, new_value: bool) -> EventWatchCall<'a, C, A> { self._always_include_email = Some(new_value); self } @@ -12063,7 +12059,7 @@ impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventWatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventWatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12084,7 +12080,7 @@ impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventWatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventWatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12101,7 +12097,7 @@ impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventWatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventWatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12140,10 +12136,10 @@ impl<'a, C, NC, A> EventWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct EventQuickAddCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventQuickAddCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CalendarHub, + hub: &'a CalendarHub, _calendar_id: String, _text: String, _send_notifications: Option, @@ -12152,9 +12148,9 @@ pub struct EventQuickAddCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventQuickAddCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventQuickAddCall<'a, C, A> {} -impl<'a, C, NC, A> EventQuickAddCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventQuickAddCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12290,7 +12286,7 @@ impl<'a, C, NC, A> EventQuickAddCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Calendar identifier. - pub fn calendar_id(mut self, new_value: &str) -> EventQuickAddCall<'a, C, NC, A> { + pub fn calendar_id(mut self, new_value: &str) -> EventQuickAddCall<'a, C, A> { self._calendar_id = new_value.to_string(); self } @@ -12300,7 +12296,7 @@ impl<'a, C, NC, A> EventQuickAddCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The text describing the event to be created. - pub fn text(mut self, new_value: &str) -> EventQuickAddCall<'a, C, NC, A> { + pub fn text(mut self, new_value: &str) -> EventQuickAddCall<'a, C, A> { self._text = new_value.to_string(); self } @@ -12308,7 +12304,7 @@ impl<'a, C, NC, A> EventQuickAddCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Whether to send notifications about the creation of the event. Optional. The default is False. - pub fn send_notifications(mut self, new_value: bool) -> EventQuickAddCall<'a, C, NC, A> { + pub fn send_notifications(mut self, new_value: bool) -> EventQuickAddCall<'a, C, A> { self._send_notifications = Some(new_value); self } @@ -12319,7 +12315,7 @@ impl<'a, C, NC, A> EventQuickAddCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventQuickAddCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventQuickAddCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12340,7 +12336,7 @@ impl<'a, C, NC, A> EventQuickAddCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventQuickAddCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventQuickAddCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12357,7 +12353,7 @@ impl<'a, C, NC, A> EventQuickAddCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventQuickAddCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventQuickAddCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/civicinfo2/Cargo.toml b/gen/civicinfo2/Cargo.toml index 7b898ed2c73..9dbe4871de6 100644 --- a/gen/civicinfo2/Cargo.toml +++ b/gen/civicinfo2/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-civicinfo2" -version = "0.1.4+20150302" +version = "0.1.5+20150302" authors = ["Sebastian Thiel "] description = "A complete library to interact with Civic Info (protocol v2)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/civicinfo2" homepage = "https://developers.google.com/civic-information" -documentation = "http://byron.github.io/google-apis-rs/google-civicinfo2" +documentation = "http://byron.github.io/google-apis-rs/google_civicinfo2" license = "MIT" keywords = ["civicinfo", "google", "protocol", "web", "api"] diff --git a/gen/civicinfo2/README.md b/gen/civicinfo2/README.md index 353eb5f65a1..b6c4a86b10f 100644 --- a/gen/civicinfo2/README.md +++ b/gen/civicinfo2/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-civicinfo2` library allows access to all features of the *Google Civic Info* service. -This documentation was generated from *Civic Info* crate version *0.1.4+20150302*, where *20150302* is the exact revision of the *civicinfo:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *Civic Info* crate version *0.1.5+20150302*, where *20150302* is the exact revision of the *civicinfo:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *Civic Info* *v2* API can be found at the [official documentation site](https://developers.google.com/civic-information). diff --git a/gen/civicinfo2/src/cmn.rs b/gen/civicinfo2/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/civicinfo2/src/cmn.rs +++ b/gen/civicinfo2/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/civicinfo2/src/lib.rs b/gen/civicinfo2/src/lib.rs index 96a6084b7a7..6202bb4d67c 100644 --- a/gen/civicinfo2/src/lib.rs +++ b/gen/civicinfo2/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *Civic Info* crate version *0.1.4+20150302*, where *20150302* is the exact revision of the *civicinfo:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *Civic Info* crate version *0.1.5+20150302*, where *20150302* is the exact revision of the *civicinfo:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *Civic Info* *v2* API can be found at the //! [official documentation site](https://developers.google.com/civic-information). @@ -195,7 +195,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -266,40 +265,37 @@ pub use cmn::{MultiPartReader, ToParts, MethodInfo, Result, Error, CallBuilder, /// } /// # } /// ``` -pub struct CivicInfo { +pub struct CivicInfo { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for CivicInfo {} +impl<'a, C, A> Hub for CivicInfo {} -impl<'a, C, NC, A> CivicInfo - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CivicInfo + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> CivicInfo { + pub fn new(client: C, authenticator: A) -> CivicInfo { CivicInfo { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn divisions(&'a self) -> DivisionMethods<'a, C, NC, A> { + pub fn divisions(&'a self) -> DivisionMethods<'a, C, A> { DivisionMethods { hub: &self } } - pub fn elections(&'a self) -> ElectionMethods<'a, C, NC, A> { + pub fn elections(&'a self) -> ElectionMethods<'a, C, A> { ElectionMethods { hub: &self } } - pub fn representatives(&'a self) -> RepresentativeMethods<'a, C, NC, A> { + pub fn representatives(&'a self) -> RepresentativeMethods<'a, C, A> { RepresentativeMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -880,20 +876,20 @@ impl Resource for Election {} /// let rb = hub.divisions(); /// # } /// ``` -pub struct DivisionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DivisionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CivicInfo, + hub: &'a CivicInfo, } -impl<'a, C, NC, A> MethodsBuilder for DivisionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for DivisionMethods<'a, C, A> {} -impl<'a, C, NC, A> DivisionMethods<'a, C, NC, A> { +impl<'a, C, A> DivisionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Searches for political divisions by their natural name or OCD ID. - pub fn search(&self) -> DivisionSearchCall<'a, C, NC, A> { + pub fn search(&self) -> DivisionSearchCall<'a, C, A> { DivisionSearchCall { hub: self.hub, _query: Default::default(), @@ -933,20 +929,20 @@ impl<'a, C, NC, A> DivisionMethods<'a, C, NC, A> { /// let rb = hub.elections(); /// # } /// ``` -pub struct ElectionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ElectionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CivicInfo, + hub: &'a CivicInfo, } -impl<'a, C, NC, A> MethodsBuilder for ElectionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ElectionMethods<'a, C, A> {} -impl<'a, C, NC, A> ElectionMethods<'a, C, NC, A> { +impl<'a, C, A> ElectionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// List of available elections to query. - pub fn election_query(&self) -> ElectionElectionQueryCall<'a, C, NC, A> { + pub fn election_query(&self) -> ElectionElectionQueryCall<'a, C, A> { ElectionElectionQueryCall { hub: self.hub, _delegate: Default::default(), @@ -961,7 +957,7 @@ impl<'a, C, NC, A> ElectionMethods<'a, C, NC, A> { /// # Arguments /// /// * `address` - The registered address of the voter to look up. - pub fn voter_info_query(&self, address: &str) -> ElectionVoterInfoQueryCall<'a, C, NC, A> { + pub fn voter_info_query(&self, address: &str) -> ElectionVoterInfoQueryCall<'a, C, A> { ElectionVoterInfoQueryCall { hub: self.hub, _address: address.to_string(), @@ -1003,20 +999,20 @@ impl<'a, C, NC, A> ElectionMethods<'a, C, NC, A> { /// let rb = hub.representatives(); /// # } /// ``` -pub struct RepresentativeMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RepresentativeMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CivicInfo, + hub: &'a CivicInfo, } -impl<'a, C, NC, A> MethodsBuilder for RepresentativeMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for RepresentativeMethods<'a, C, A> {} -impl<'a, C, NC, A> RepresentativeMethods<'a, C, NC, A> { +impl<'a, C, A> RepresentativeMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Looks up political geography and representative information for a single address. - pub fn representative_info_by_address(&self) -> RepresentativeRepresentativeInfoByAddresCall<'a, C, NC, A> { + pub fn representative_info_by_address(&self) -> RepresentativeRepresentativeInfoByAddresCall<'a, C, A> { RepresentativeRepresentativeInfoByAddresCall { hub: self.hub, _roles: Default::default(), @@ -1035,7 +1031,7 @@ impl<'a, C, NC, A> RepresentativeMethods<'a, C, NC, A> { /// # Arguments /// /// * `ocdId` - The Open Civic Data division identifier of the division to look up. - pub fn representative_info_by_division(&self, ocd_id: &str) -> RepresentativeRepresentativeInfoByDivisionCall<'a, C, NC, A> { + pub fn representative_info_by_division(&self, ocd_id: &str) -> RepresentativeRepresentativeInfoByDivisionCall<'a, C, A> { RepresentativeRepresentativeInfoByDivisionCall { hub: self.hub, _ocd_id: ocd_id.to_string(), @@ -1087,18 +1083,18 @@ impl<'a, C, NC, A> RepresentativeMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct DivisionSearchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DivisionSearchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CivicInfo, + hub: &'a CivicInfo, _query: Option, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for DivisionSearchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DivisionSearchCall<'a, C, A> {} -impl<'a, C, NC, A> DivisionSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DivisionSearchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1204,7 +1200,7 @@ impl<'a, C, NC, A> DivisionSearchCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The search query. Queries can cover any parts of a OCD ID or a human readable division name. All words given in the query are treated as required patterns. In addition to that, most query operators of the Apache Lucene library are supported. See http://lucene.apache.org/core/2_9_4/queryparsersyntax.html - pub fn query(mut self, new_value: &str) -> DivisionSearchCall<'a, C, NC, A> { + pub fn query(mut self, new_value: &str) -> DivisionSearchCall<'a, C, A> { self._query = Some(new_value.to_string()); self } @@ -1215,7 +1211,7 @@ impl<'a, C, NC, A> DivisionSearchCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DivisionSearchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DivisionSearchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1236,7 +1232,7 @@ impl<'a, C, NC, A> DivisionSearchCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DivisionSearchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DivisionSearchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1275,17 +1271,17 @@ impl<'a, C, NC, A> DivisionSearchCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct ElectionElectionQueryCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ElectionElectionQueryCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CivicInfo, + hub: &'a CivicInfo, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for ElectionElectionQueryCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ElectionElectionQueryCall<'a, C, A> {} -impl<'a, C, NC, A> ElectionElectionQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ElectionElectionQueryCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1391,7 +1387,7 @@ impl<'a, C, NC, A> ElectionElectionQueryCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ElectionElectionQueryCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ElectionElectionQueryCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1412,7 +1408,7 @@ impl<'a, C, NC, A> ElectionElectionQueryCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ElectionElectionQueryCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ElectionElectionQueryCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1453,10 +1449,10 @@ impl<'a, C, NC, A> ElectionElectionQueryCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct ElectionVoterInfoQueryCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ElectionVoterInfoQueryCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CivicInfo, + hub: &'a CivicInfo, _address: String, _official_only: Option, _election_id: Option, @@ -1464,9 +1460,9 @@ pub struct ElectionVoterInfoQueryCall<'a, C, NC, A> _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for ElectionVoterInfoQueryCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ElectionVoterInfoQueryCall<'a, C, A> {} -impl<'a, C, NC, A> ElectionVoterInfoQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ElectionVoterInfoQueryCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1578,7 +1574,7 @@ impl<'a, C, NC, A> ElectionVoterInfoQueryCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The registered address of the voter to look up. - pub fn address(mut self, new_value: &str) -> ElectionVoterInfoQueryCall<'a, C, NC, A> { + pub fn address(mut self, new_value: &str) -> ElectionVoterInfoQueryCall<'a, C, A> { self._address = new_value.to_string(); self } @@ -1586,7 +1582,7 @@ impl<'a, C, NC, A> ElectionVoterInfoQueryCall<'a, C, NC, A> where NC: hyper::net /// /// /// If set to true, only data from official state sources will be returned. - pub fn official_only(mut self, new_value: bool) -> ElectionVoterInfoQueryCall<'a, C, NC, A> { + pub fn official_only(mut self, new_value: bool) -> ElectionVoterInfoQueryCall<'a, C, A> { self._official_only = Some(new_value); self } @@ -1594,7 +1590,7 @@ impl<'a, C, NC, A> ElectionVoterInfoQueryCall<'a, C, NC, A> where NC: hyper::net /// /// /// The unique ID of the election to look up. A list of election IDs can be obtained at https://www.googleapis.com/civicinfo/{version}/elections - pub fn election_id(mut self, new_value: &str) -> ElectionVoterInfoQueryCall<'a, C, NC, A> { + pub fn election_id(mut self, new_value: &str) -> ElectionVoterInfoQueryCall<'a, C, A> { self._election_id = Some(new_value.to_string()); self } @@ -1605,7 +1601,7 @@ impl<'a, C, NC, A> ElectionVoterInfoQueryCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ElectionVoterInfoQueryCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ElectionVoterInfoQueryCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1626,7 +1622,7 @@ impl<'a, C, NC, A> ElectionVoterInfoQueryCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ElectionVoterInfoQueryCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ElectionVoterInfoQueryCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1669,10 +1665,10 @@ impl<'a, C, NC, A> ElectionVoterInfoQueryCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct RepresentativeRepresentativeInfoByAddresCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RepresentativeRepresentativeInfoByAddresCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CivicInfo, + hub: &'a CivicInfo, _roles: Vec, _levels: Vec, _include_offices: Option, @@ -1681,9 +1677,9 @@ pub struct RepresentativeRepresentativeInfoByAddresCall<'a, C, NC, A> _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for RepresentativeRepresentativeInfoByAddresCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RepresentativeRepresentativeInfoByAddresCall<'a, C, A> {} -impl<'a, C, NC, A> RepresentativeRepresentativeInfoByAddresCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RepresentativeRepresentativeInfoByAddresCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1807,7 +1803,7 @@ impl<'a, C, NC, A> RepresentativeRepresentativeInfoByAddresCall<'a, C, NC, A> wh /// /// /// A list of office roles to filter by. Only offices fulfilling one of these roles will be returned. Divisions that don't contain a matching office will not be returned. - pub fn add_roles(mut self, new_value: &str) -> RepresentativeRepresentativeInfoByAddresCall<'a, C, NC, A> { + pub fn add_roles(mut self, new_value: &str) -> RepresentativeRepresentativeInfoByAddresCall<'a, C, A> { self._roles.push(new_value.to_string()); self } @@ -1816,7 +1812,7 @@ impl<'a, C, NC, A> RepresentativeRepresentativeInfoByAddresCall<'a, C, NC, A> wh /// /// /// A list of office levels to filter by. Only offices that serve at least one of these levels will be returned. Divisions that don't contain a matching office will not be returned. - pub fn add_levels(mut self, new_value: &str) -> RepresentativeRepresentativeInfoByAddresCall<'a, C, NC, A> { + pub fn add_levels(mut self, new_value: &str) -> RepresentativeRepresentativeInfoByAddresCall<'a, C, A> { self._levels.push(new_value.to_string()); self } @@ -1824,7 +1820,7 @@ impl<'a, C, NC, A> RepresentativeRepresentativeInfoByAddresCall<'a, C, NC, A> wh /// /// /// Whether to return information about offices and officials. If false, only the top-level district information will be returned. - pub fn include_offices(mut self, new_value: bool) -> RepresentativeRepresentativeInfoByAddresCall<'a, C, NC, A> { + pub fn include_offices(mut self, new_value: bool) -> RepresentativeRepresentativeInfoByAddresCall<'a, C, A> { self._include_offices = Some(new_value); self } @@ -1832,7 +1828,7 @@ impl<'a, C, NC, A> RepresentativeRepresentativeInfoByAddresCall<'a, C, NC, A> wh /// /// /// The address to look up. May only be specified if the field ocdId is not given in the URL. - pub fn address(mut self, new_value: &str) -> RepresentativeRepresentativeInfoByAddresCall<'a, C, NC, A> { + pub fn address(mut self, new_value: &str) -> RepresentativeRepresentativeInfoByAddresCall<'a, C, A> { self._address = Some(new_value.to_string()); self } @@ -1843,7 +1839,7 @@ impl<'a, C, NC, A> RepresentativeRepresentativeInfoByAddresCall<'a, C, NC, A> wh /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RepresentativeRepresentativeInfoByAddresCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RepresentativeRepresentativeInfoByAddresCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1864,7 +1860,7 @@ impl<'a, C, NC, A> RepresentativeRepresentativeInfoByAddresCall<'a, C, NC, A> wh /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RepresentativeRepresentativeInfoByAddresCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RepresentativeRepresentativeInfoByAddresCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1906,10 +1902,10 @@ impl<'a, C, NC, A> RepresentativeRepresentativeInfoByAddresCall<'a, C, NC, A> wh /// .doit(); /// # } /// ``` -pub struct RepresentativeRepresentativeInfoByDivisionCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RepresentativeRepresentativeInfoByDivisionCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CivicInfo, + hub: &'a CivicInfo, _ocd_id: String, _roles: Vec, _recursive: Option, @@ -1918,9 +1914,9 @@ pub struct RepresentativeRepresentativeInfoByDivisionCall<'a, C, NC, A> _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for RepresentativeRepresentativeInfoByDivisionCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RepresentativeRepresentativeInfoByDivisionCall<'a, C, A> {} -impl<'a, C, NC, A> RepresentativeRepresentativeInfoByDivisionCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RepresentativeRepresentativeInfoByDivisionCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2067,7 +2063,7 @@ impl<'a, C, NC, A> RepresentativeRepresentativeInfoByDivisionCall<'a, C, NC, A> /// we provide this method for API completeness. /// /// The Open Civic Data division identifier of the division to look up. - pub fn ocd_id(mut self, new_value: &str) -> RepresentativeRepresentativeInfoByDivisionCall<'a, C, NC, A> { + pub fn ocd_id(mut self, new_value: &str) -> RepresentativeRepresentativeInfoByDivisionCall<'a, C, A> { self._ocd_id = new_value.to_string(); self } @@ -2076,7 +2072,7 @@ impl<'a, C, NC, A> RepresentativeRepresentativeInfoByDivisionCall<'a, C, NC, A> /// /// /// A list of office roles to filter by. Only offices fulfilling one of these roles will be returned. Divisions that don't contain a matching office will not be returned. - pub fn add_roles(mut self, new_value: &str) -> RepresentativeRepresentativeInfoByDivisionCall<'a, C, NC, A> { + pub fn add_roles(mut self, new_value: &str) -> RepresentativeRepresentativeInfoByDivisionCall<'a, C, A> { self._roles.push(new_value.to_string()); self } @@ -2084,7 +2080,7 @@ impl<'a, C, NC, A> RepresentativeRepresentativeInfoByDivisionCall<'a, C, NC, A> /// /// /// If true, information about all divisions contained in the division requested will be included as well. For example, if querying ocd-division/country:us/district:dc, this would also return all DC's wards and ANCs. - pub fn recursive(mut self, new_value: bool) -> RepresentativeRepresentativeInfoByDivisionCall<'a, C, NC, A> { + pub fn recursive(mut self, new_value: bool) -> RepresentativeRepresentativeInfoByDivisionCall<'a, C, A> { self._recursive = Some(new_value); self } @@ -2093,7 +2089,7 @@ impl<'a, C, NC, A> RepresentativeRepresentativeInfoByDivisionCall<'a, C, NC, A> /// /// /// A list of office levels to filter by. Only offices that serve at least one of these levels will be returned. Divisions that don't contain a matching office will not be returned. - pub fn add_levels(mut self, new_value: &str) -> RepresentativeRepresentativeInfoByDivisionCall<'a, C, NC, A> { + pub fn add_levels(mut self, new_value: &str) -> RepresentativeRepresentativeInfoByDivisionCall<'a, C, A> { self._levels.push(new_value.to_string()); self } @@ -2104,7 +2100,7 @@ impl<'a, C, NC, A> RepresentativeRepresentativeInfoByDivisionCall<'a, C, NC, A> /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RepresentativeRepresentativeInfoByDivisionCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RepresentativeRepresentativeInfoByDivisionCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2125,7 +2121,7 @@ impl<'a, C, NC, A> RepresentativeRepresentativeInfoByDivisionCall<'a, C, NC, A> /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RepresentativeRepresentativeInfoByDivisionCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RepresentativeRepresentativeInfoByDivisionCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self diff --git a/gen/cloudlatencytest2/Cargo.toml b/gen/cloudlatencytest2/Cargo.toml index f0a1bc31886..039cba6f2f4 100644 --- a/gen/cloudlatencytest2/Cargo.toml +++ b/gen/cloudlatencytest2/Cargo.toml @@ -4,11 +4,11 @@ [package] name = "google-cloudlatencytest2" -version = "0.1.4+20150206" +version = "0.1.5+20150206" authors = ["Sebastian Thiel "] description = "A complete library to interact with cloudlatencytest (protocol v2)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/cloudlatencytest2" -documentation = "http://byron.github.io/google-apis-rs/google-cloudlatencytest2" +documentation = "http://byron.github.io/google-apis-rs/google_cloudlatencytest2" license = "MIT" keywords = ["cloudlatencytest", "google", "protocol", "web", "api"] diff --git a/gen/cloudlatencytest2/README.md b/gen/cloudlatencytest2/README.md index d5109e93a66..201dc3e7904 100644 --- a/gen/cloudlatencytest2/README.md +++ b/gen/cloudlatencytest2/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-cloudlatencytest2` library allows access to all features of the *Google cloudlatencytest* service. -This documentation was generated from *cloudlatencytest* crate version *0.1.4+20150206*, where *20150206* is the exact revision of the *cloudlatencytest:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *cloudlatencytest* crate version *0.1.5+20150206*, where *20150206* is the exact revision of the *cloudlatencytest:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. # Features Handle the following *Resources* with ease from the central [hub](http://byron.github.io/google-apis-rs/google-cloudlatencytest2/struct.Cloudlatencytest.html) ... diff --git a/gen/cloudlatencytest2/src/cmn.rs b/gen/cloudlatencytest2/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/cloudlatencytest2/src/cmn.rs +++ b/gen/cloudlatencytest2/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/cloudlatencytest2/src/lib.rs b/gen/cloudlatencytest2/src/lib.rs index 07fad4a6cde..6578e2d9147 100644 --- a/gen/cloudlatencytest2/src/lib.rs +++ b/gen/cloudlatencytest2/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *cloudlatencytest* crate version *0.1.4+20150206*, where *20150206* is the exact revision of the *cloudlatencytest:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *cloudlatencytest* crate version *0.1.5+20150206*, where *20150206* is the exact revision of the *cloudlatencytest:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/master/gen/cloudlatencytest2). //! # Features //! @@ -191,7 +191,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -288,34 +287,31 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Cloudlatencytest { +pub struct Cloudlatencytest { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Cloudlatencytest {} +impl<'a, C, A> Hub for Cloudlatencytest {} -impl<'a, C, NC, A> Cloudlatencytest - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Cloudlatencytest + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Cloudlatencytest { + pub fn new(client: C, authenticator: A) -> Cloudlatencytest { Cloudlatencytest { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn statscollection(&'a self) -> StatscollectionMethods<'a, C, NC, A> { + pub fn statscollection(&'a self) -> StatscollectionMethods<'a, C, A> { StatscollectionMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -490,15 +486,15 @@ impl ResponseResult for StatsReply {} /// let rb = hub.statscollection(); /// # } /// ``` -pub struct StatscollectionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct StatscollectionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Cloudlatencytest, + hub: &'a Cloudlatencytest, } -impl<'a, C, NC, A> MethodsBuilder for StatscollectionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for StatscollectionMethods<'a, C, A> {} -impl<'a, C, NC, A> StatscollectionMethods<'a, C, NC, A> { +impl<'a, C, A> StatscollectionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -507,7 +503,7 @@ impl<'a, C, NC, A> StatscollectionMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn updateaggregatedstats(&self, request: &AggregatedStats) -> StatscollectionUpdateaggregatedstatCall<'a, C, NC, A> { + pub fn updateaggregatedstats(&self, request: &AggregatedStats) -> StatscollectionUpdateaggregatedstatCall<'a, C, A> { StatscollectionUpdateaggregatedstatCall { hub: self.hub, _request: request.clone(), @@ -524,7 +520,7 @@ impl<'a, C, NC, A> StatscollectionMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn updatestats(&self, request: &Stats) -> StatscollectionUpdatestatCall<'a, C, NC, A> { + pub fn updatestats(&self, request: &Stats) -> StatscollectionUpdatestatCall<'a, C, A> { StatscollectionUpdatestatCall { hub: self.hub, _request: request.clone(), @@ -579,19 +575,19 @@ impl<'a, C, NC, A> StatscollectionMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct StatscollectionUpdateaggregatedstatCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct StatscollectionUpdateaggregatedstatCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Cloudlatencytest, + hub: &'a Cloudlatencytest, _request: AggregatedStats, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for StatscollectionUpdateaggregatedstatCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for StatscollectionUpdateaggregatedstatCall<'a, C, A> {} -impl<'a, C, NC, A> StatscollectionUpdateaggregatedstatCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> StatscollectionUpdateaggregatedstatCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -705,7 +701,7 @@ impl<'a, C, NC, A> StatscollectionUpdateaggregatedstatCall<'a, C, NC, A> where N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AggregatedStats) -> StatscollectionUpdateaggregatedstatCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AggregatedStats) -> StatscollectionUpdateaggregatedstatCall<'a, C, A> { self._request = new_value.clone(); self } @@ -716,7 +712,7 @@ impl<'a, C, NC, A> StatscollectionUpdateaggregatedstatCall<'a, C, NC, A> where N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> StatscollectionUpdateaggregatedstatCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> StatscollectionUpdateaggregatedstatCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -737,7 +733,7 @@ impl<'a, C, NC, A> StatscollectionUpdateaggregatedstatCall<'a, C, NC, A> where N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> StatscollectionUpdateaggregatedstatCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> StatscollectionUpdateaggregatedstatCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -754,7 +750,7 @@ impl<'a, C, NC, A> StatscollectionUpdateaggregatedstatCall<'a, C, NC, A> where N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> StatscollectionUpdateaggregatedstatCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> StatscollectionUpdateaggregatedstatCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -798,19 +794,19 @@ impl<'a, C, NC, A> StatscollectionUpdateaggregatedstatCall<'a, C, NC, A> where N /// .doit(); /// # } /// ``` -pub struct StatscollectionUpdatestatCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct StatscollectionUpdatestatCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Cloudlatencytest, + hub: &'a Cloudlatencytest, _request: Stats, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for StatscollectionUpdatestatCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for StatscollectionUpdatestatCall<'a, C, A> {} -impl<'a, C, NC, A> StatscollectionUpdatestatCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> StatscollectionUpdatestatCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -924,7 +920,7 @@ impl<'a, C, NC, A> StatscollectionUpdatestatCall<'a, C, NC, A> where NC: hyper:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Stats) -> StatscollectionUpdatestatCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Stats) -> StatscollectionUpdatestatCall<'a, C, A> { self._request = new_value.clone(); self } @@ -935,7 +931,7 @@ impl<'a, C, NC, A> StatscollectionUpdatestatCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> StatscollectionUpdatestatCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> StatscollectionUpdatestatCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -956,7 +952,7 @@ impl<'a, C, NC, A> StatscollectionUpdatestatCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> StatscollectionUpdatestatCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> StatscollectionUpdatestatCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -973,7 +969,7 @@ impl<'a, C, NC, A> StatscollectionUpdatestatCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> StatscollectionUpdatestatCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> StatscollectionUpdatestatCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/cloudmonitoring2_beta2/Cargo.toml b/gen/cloudmonitoring2_beta2/Cargo.toml index f93a8fa0b26..ef541aebd1e 100644 --- a/gen/cloudmonitoring2_beta2/Cargo.toml +++ b/gen/cloudmonitoring2_beta2/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-cloudmonitoring2_beta2" -version = "0.1.4+20150303" +version = "0.1.5+20150303" authors = ["Sebastian Thiel "] description = "A complete library to interact with Cloud Monitoring (protocol v2beta2)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/cloudmonitoring2_beta2" homepage = "https://cloud.google.com/monitoring/v2beta2/" -documentation = "http://byron.github.io/google-apis-rs/google-cloudmonitoring2_beta2" +documentation = "http://byron.github.io/google-apis-rs/google_cloudmonitoring2_beta2" license = "MIT" keywords = ["cloudmonitoring", "google", "protocol", "web", "api"] diff --git a/gen/cloudmonitoring2_beta2/README.md b/gen/cloudmonitoring2_beta2/README.md index 7cdd7ecd1db..664d1ae43a3 100644 --- a/gen/cloudmonitoring2_beta2/README.md +++ b/gen/cloudmonitoring2_beta2/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-cloudmonitoring2_beta2` library allows access to all features of the *Google Cloud Monitoring* service. -This documentation was generated from *Cloud Monitoring* crate version *0.1.4+20150303*, where *20150303* is the exact revision of the *cloudmonitoring:v2beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *Cloud Monitoring* crate version *0.1.5+20150303*, where *20150303* is the exact revision of the *cloudmonitoring:v2beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *Cloud Monitoring* *v2_beta2* API can be found at the [official documentation site](https://cloud.google.com/monitoring/v2beta2/). diff --git a/gen/cloudmonitoring2_beta2/src/cmn.rs b/gen/cloudmonitoring2_beta2/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/cloudmonitoring2_beta2/src/cmn.rs +++ b/gen/cloudmonitoring2_beta2/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/cloudmonitoring2_beta2/src/lib.rs b/gen/cloudmonitoring2_beta2/src/lib.rs index e8219181285..f276a08bc61 100644 --- a/gen/cloudmonitoring2_beta2/src/lib.rs +++ b/gen/cloudmonitoring2_beta2/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *Cloud Monitoring* crate version *0.1.4+20150303*, where *20150303* is the exact revision of the *cloudmonitoring:v2beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *Cloud Monitoring* crate version *0.1.5+20150303*, where *20150303* is the exact revision of the *cloudmonitoring:v2beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *Cloud Monitoring* *v2_beta2* API can be found at the //! [official documentation site](https://cloud.google.com/monitoring/v2beta2/). @@ -203,7 +203,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -303,40 +302,37 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct CloudMonitoring { +pub struct CloudMonitoring { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for CloudMonitoring {} +impl<'a, C, A> Hub for CloudMonitoring {} -impl<'a, C, NC, A> CloudMonitoring - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CloudMonitoring + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> CloudMonitoring { + pub fn new(client: C, authenticator: A) -> CloudMonitoring { CloudMonitoring { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn metric_descriptors(&'a self) -> MetricDescriptorMethods<'a, C, NC, A> { + pub fn metric_descriptors(&'a self) -> MetricDescriptorMethods<'a, C, A> { MetricDescriptorMethods { hub: &self } } - pub fn timeseries(&'a self) -> TimeseryMethods<'a, C, NC, A> { + pub fn timeseries(&'a self) -> TimeseryMethods<'a, C, A> { TimeseryMethods { hub: &self } } - pub fn timeseries_descriptors(&'a self) -> TimeseriesDescriptorMethods<'a, C, NC, A> { + pub fn timeseries_descriptors(&'a self) -> TimeseriesDescriptorMethods<'a, C, A> { TimeseriesDescriptorMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -788,15 +784,15 @@ impl ResponseResult for ListTimeseriesResponse {} /// let rb = hub.timeseries_descriptors(); /// # } /// ``` -pub struct TimeseriesDescriptorMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TimeseriesDescriptorMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CloudMonitoring, + hub: &'a CloudMonitoring, } -impl<'a, C, NC, A> MethodsBuilder for TimeseriesDescriptorMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TimeseriesDescriptorMethods<'a, C, A> {} -impl<'a, C, NC, A> TimeseriesDescriptorMethods<'a, C, NC, A> { +impl<'a, C, A> TimeseriesDescriptorMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -808,7 +804,7 @@ impl<'a, C, NC, A> TimeseriesDescriptorMethods<'a, C, NC, A> { /// * `project` - The project ID to which this time series belongs. The value can be the numeric project ID or string-based project name. /// * `metric` - Metric names are protocol-free URLs as listed in the Supported Metrics page. For example, compute.googleapis.com/instance/disk/read_ops_count. /// * `youngest` - End of the time interval (inclusive), which is expressed as an RFC 3339 timestamp. - pub fn list(&self, request: &ListTimeseriesDescriptorsRequest, project: &str, metric: &str, youngest: &str) -> TimeseriesDescriptorListCall<'a, C, NC, A> { + pub fn list(&self, request: &ListTimeseriesDescriptorsRequest, project: &str, metric: &str, youngest: &str) -> TimeseriesDescriptorListCall<'a, C, A> { TimeseriesDescriptorListCall { hub: self.hub, _request: request.clone(), @@ -859,15 +855,15 @@ impl<'a, C, NC, A> TimeseriesDescriptorMethods<'a, C, NC, A> { /// let rb = hub.timeseries(); /// # } /// ``` -pub struct TimeseryMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TimeseryMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CloudMonitoring, + hub: &'a CloudMonitoring, } -impl<'a, C, NC, A> MethodsBuilder for TimeseryMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TimeseryMethods<'a, C, A> {} -impl<'a, C, NC, A> TimeseryMethods<'a, C, NC, A> { +impl<'a, C, A> TimeseryMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -877,7 +873,7 @@ impl<'a, C, NC, A> TimeseryMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `project` - The project ID. The value can be the numeric project ID or string-based project name. - pub fn write(&self, request: &WriteTimeseriesRequest, project: &str) -> TimeseryWriteCall<'a, C, NC, A> { + pub fn write(&self, request: &WriteTimeseriesRequest, project: &str) -> TimeseryWriteCall<'a, C, A> { TimeseryWriteCall { hub: self.hub, _request: request.clone(), @@ -898,7 +894,7 @@ impl<'a, C, NC, A> TimeseryMethods<'a, C, NC, A> { /// * `project` - The project ID to which this time series belongs. The value can be the numeric project ID or string-based project name. /// * `metric` - Metric names are protocol-free URLs as listed in the Supported Metrics page. For example, compute.googleapis.com/instance/disk/read_ops_count. /// * `youngest` - End of the time interval (inclusive), which is expressed as an RFC 3339 timestamp. - pub fn list(&self, request: &ListTimeseriesRequest, project: &str, metric: &str, youngest: &str) -> TimeseryListCall<'a, C, NC, A> { + pub fn list(&self, request: &ListTimeseriesRequest, project: &str, metric: &str, youngest: &str) -> TimeseryListCall<'a, C, A> { TimeseryListCall { hub: self.hub, _request: request.clone(), @@ -949,15 +945,15 @@ impl<'a, C, NC, A> TimeseryMethods<'a, C, NC, A> { /// let rb = hub.metric_descriptors(); /// # } /// ``` -pub struct MetricDescriptorMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MetricDescriptorMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CloudMonitoring, + hub: &'a CloudMonitoring, } -impl<'a, C, NC, A> MethodsBuilder for MetricDescriptorMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for MetricDescriptorMethods<'a, C, A> {} -impl<'a, C, NC, A> MetricDescriptorMethods<'a, C, NC, A> { +impl<'a, C, A> MetricDescriptorMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -967,7 +963,7 @@ impl<'a, C, NC, A> MetricDescriptorMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `project` - The project id. The value can be the numeric project ID or string-based project name. - pub fn list(&self, request: &ListMetricDescriptorsRequest, project: &str) -> MetricDescriptorListCall<'a, C, NC, A> { + pub fn list(&self, request: &ListMetricDescriptorsRequest, project: &str) -> MetricDescriptorListCall<'a, C, A> { MetricDescriptorListCall { hub: self.hub, _request: request.clone(), @@ -989,7 +985,7 @@ impl<'a, C, NC, A> MetricDescriptorMethods<'a, C, NC, A> { /// /// * `project` - The project ID to which the metric belongs. /// * `metric` - Name of the metric. - pub fn delete(&self, project: &str, metric: &str) -> MetricDescriptorDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, metric: &str) -> MetricDescriptorDeleteCall<'a, C, A> { MetricDescriptorDeleteCall { hub: self.hub, _project: project.to_string(), @@ -1008,7 +1004,7 @@ impl<'a, C, NC, A> MetricDescriptorMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `project` - The project id. The value can be the numeric project ID or string-based project name. - pub fn create(&self, request: &MetricDescriptor, project: &str) -> MetricDescriptorCreateCall<'a, C, NC, A> { + pub fn create(&self, request: &MetricDescriptor, project: &str) -> MetricDescriptorCreateCall<'a, C, A> { MetricDescriptorCreateCall { hub: self.hub, _request: request.clone(), @@ -1071,10 +1067,10 @@ impl<'a, C, NC, A> MetricDescriptorMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct TimeseriesDescriptorListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TimeseriesDescriptorListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CloudMonitoring, + hub: &'a CloudMonitoring, _request: ListTimeseriesDescriptorsRequest, _project: String, _metric: String, @@ -1091,9 +1087,9 @@ pub struct TimeseriesDescriptorListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TimeseriesDescriptorListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TimeseriesDescriptorListCall<'a, C, A> {} -impl<'a, C, NC, A> TimeseriesDescriptorListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TimeseriesDescriptorListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1259,7 +1255,7 @@ impl<'a, C, NC, A> TimeseriesDescriptorListCall<'a, C, NC, A> where NC: hyper::n /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ListTimeseriesDescriptorsRequest) -> TimeseriesDescriptorListCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ListTimeseriesDescriptorsRequest) -> TimeseriesDescriptorListCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1269,7 +1265,7 @@ impl<'a, C, NC, A> TimeseriesDescriptorListCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The project ID to which this time series belongs. The value can be the numeric project ID or string-based project name. - pub fn project(mut self, new_value: &str) -> TimeseriesDescriptorListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TimeseriesDescriptorListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1279,7 +1275,7 @@ impl<'a, C, NC, A> TimeseriesDescriptorListCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Metric names are protocol-free URLs as listed in the Supported Metrics page. For example, compute.googleapis.com/instance/disk/read_ops_count. - pub fn metric(mut self, new_value: &str) -> TimeseriesDescriptorListCall<'a, C, NC, A> { + pub fn metric(mut self, new_value: &str) -> TimeseriesDescriptorListCall<'a, C, A> { self._metric = new_value.to_string(); self } @@ -1289,7 +1285,7 @@ impl<'a, C, NC, A> TimeseriesDescriptorListCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// End of the time interval (inclusive), which is expressed as an RFC 3339 timestamp. - pub fn youngest(mut self, new_value: &str) -> TimeseriesDescriptorListCall<'a, C, NC, A> { + pub fn youngest(mut self, new_value: &str) -> TimeseriesDescriptorListCall<'a, C, A> { self._youngest = new_value.to_string(); self } @@ -1301,7 +1297,7 @@ impl<'a, C, NC, A> TimeseriesDescriptorListCall<'a, C, NC, A> where NC: hyper::n /// - h: hour /// - d: day /// - w: week Examples: 3m, 4w. Only one unit is allowed, for example: 2w3d is not allowed; you should use 17d instead. - pub fn window(mut self, new_value: &str) -> TimeseriesDescriptorListCall<'a, C, NC, A> { + pub fn window(mut self, new_value: &str) -> TimeseriesDescriptorListCall<'a, C, A> { self._window = Some(new_value.to_string()); self } @@ -1316,7 +1312,7 @@ impl<'a, C, NC, A> TimeseriesDescriptorListCall<'a, C, NC, A> where NC: hyper::n /// - w: week Examples: 2s, 3m, 4w. Only one unit is allowed, for example: 2w3d is not allowed; you should use 17d instead. /// /// If neither oldest nor timespan is specified, the default time interval will be (youngest - 4 hours, youngest]. - pub fn timespan(mut self, new_value: &str) -> TimeseriesDescriptorListCall<'a, C, NC, A> { + pub fn timespan(mut self, new_value: &str) -> TimeseriesDescriptorListCall<'a, C, A> { self._timespan = Some(new_value.to_string()); self } @@ -1324,7 +1320,7 @@ impl<'a, C, NC, A> TimeseriesDescriptorListCall<'a, C, NC, A> where NC: hyper::n /// /// /// The pagination token, which is used to page through large result sets. Set this value to the value of the nextPageToken to retrieve the next page of results. - pub fn page_token(mut self, new_value: &str) -> TimeseriesDescriptorListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TimeseriesDescriptorListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -1332,7 +1328,7 @@ impl<'a, C, NC, A> TimeseriesDescriptorListCall<'a, C, NC, A> where NC: hyper::n /// /// /// Start of the time interval (exclusive), which is expressed as an RFC 3339 timestamp. If neither oldest nor timespan is specified, the default time interval will be (youngest - 4 hours, youngest] - pub fn oldest(mut self, new_value: &str) -> TimeseriesDescriptorListCall<'a, C, NC, A> { + pub fn oldest(mut self, new_value: &str) -> TimeseriesDescriptorListCall<'a, C, A> { self._oldest = Some(new_value.to_string()); self } @@ -1346,7 +1342,7 @@ impl<'a, C, NC, A> TimeseriesDescriptorListCall<'a, C, NC, A> where NC: hyper::n /// - key!=value: key does not equal the value /// - key!~value: key regex does not match the value For example, to list all of the time series descriptors for the region us-central1, you could specify: /// label=cloud.googleapis.com%2Flocation=~us-central1.* - pub fn add_labels(mut self, new_value: &str) -> TimeseriesDescriptorListCall<'a, C, NC, A> { + pub fn add_labels(mut self, new_value: &str) -> TimeseriesDescriptorListCall<'a, C, A> { self._labels.push(new_value.to_string()); self } @@ -1354,7 +1350,7 @@ impl<'a, C, NC, A> TimeseriesDescriptorListCall<'a, C, NC, A> where NC: hyper::n /// /// /// Maximum number of time series descriptors per page. Used for pagination. If not specified, count = 100. - pub fn count(mut self, new_value: i32) -> TimeseriesDescriptorListCall<'a, C, NC, A> { + pub fn count(mut self, new_value: i32) -> TimeseriesDescriptorListCall<'a, C, A> { self._count = Some(new_value); self } @@ -1362,7 +1358,7 @@ impl<'a, C, NC, A> TimeseriesDescriptorListCall<'a, C, NC, A> where NC: hyper::n /// /// /// The aggregation function that will reduce the data points in each window to a single point. This parameter is only valid for non-cumulative metrics with a value type of INT64 or DOUBLE. - pub fn aggregator(mut self, new_value: &str) -> TimeseriesDescriptorListCall<'a, C, NC, A> { + pub fn aggregator(mut self, new_value: &str) -> TimeseriesDescriptorListCall<'a, C, A> { self._aggregator = Some(new_value.to_string()); self } @@ -1373,7 +1369,7 @@ impl<'a, C, NC, A> TimeseriesDescriptorListCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimeseriesDescriptorListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimeseriesDescriptorListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1394,7 +1390,7 @@ impl<'a, C, NC, A> TimeseriesDescriptorListCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TimeseriesDescriptorListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TimeseriesDescriptorListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1411,7 +1407,7 @@ impl<'a, C, NC, A> TimeseriesDescriptorListCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TimeseriesDescriptorListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TimeseriesDescriptorListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1455,10 +1451,10 @@ impl<'a, C, NC, A> TimeseriesDescriptorListCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct TimeseryWriteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TimeseryWriteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CloudMonitoring, + hub: &'a CloudMonitoring, _request: WriteTimeseriesRequest, _project: String, _delegate: Option<&'a mut Delegate>, @@ -1466,9 +1462,9 @@ pub struct TimeseryWriteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TimeseryWriteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TimeseryWriteCall<'a, C, A> {} -impl<'a, C, NC, A> TimeseryWriteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TimeseryWriteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1607,7 +1603,7 @@ impl<'a, C, NC, A> TimeseryWriteCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &WriteTimeseriesRequest) -> TimeseryWriteCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &WriteTimeseriesRequest) -> TimeseryWriteCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1617,7 +1613,7 @@ impl<'a, C, NC, A> TimeseryWriteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The project ID. The value can be the numeric project ID or string-based project name. - pub fn project(mut self, new_value: &str) -> TimeseryWriteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TimeseryWriteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1628,7 +1624,7 @@ impl<'a, C, NC, A> TimeseryWriteCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimeseryWriteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimeseryWriteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1649,7 +1645,7 @@ impl<'a, C, NC, A> TimeseryWriteCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TimeseryWriteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TimeseryWriteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1666,7 +1662,7 @@ impl<'a, C, NC, A> TimeseryWriteCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TimeseryWriteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TimeseryWriteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1717,10 +1713,10 @@ impl<'a, C, NC, A> TimeseryWriteCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct TimeseryListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TimeseryListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CloudMonitoring, + hub: &'a CloudMonitoring, _request: ListTimeseriesRequest, _project: String, _metric: String, @@ -1737,9 +1733,9 @@ pub struct TimeseryListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TimeseryListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TimeseryListCall<'a, C, A> {} -impl<'a, C, NC, A> TimeseryListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TimeseryListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1905,7 +1901,7 @@ impl<'a, C, NC, A> TimeseryListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ListTimeseriesRequest) -> TimeseryListCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ListTimeseriesRequest) -> TimeseryListCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1915,7 +1911,7 @@ impl<'a, C, NC, A> TimeseryListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The project ID to which this time series belongs. The value can be the numeric project ID or string-based project name. - pub fn project(mut self, new_value: &str) -> TimeseryListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TimeseryListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1925,7 +1921,7 @@ impl<'a, C, NC, A> TimeseryListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Metric names are protocol-free URLs as listed in the Supported Metrics page. For example, compute.googleapis.com/instance/disk/read_ops_count. - pub fn metric(mut self, new_value: &str) -> TimeseryListCall<'a, C, NC, A> { + pub fn metric(mut self, new_value: &str) -> TimeseryListCall<'a, C, A> { self._metric = new_value.to_string(); self } @@ -1935,7 +1931,7 @@ impl<'a, C, NC, A> TimeseryListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// End of the time interval (inclusive), which is expressed as an RFC 3339 timestamp. - pub fn youngest(mut self, new_value: &str) -> TimeseryListCall<'a, C, NC, A> { + pub fn youngest(mut self, new_value: &str) -> TimeseryListCall<'a, C, A> { self._youngest = new_value.to_string(); self } @@ -1947,7 +1943,7 @@ impl<'a, C, NC, A> TimeseryListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// - h: hour /// - d: day /// - w: week Examples: 3m, 4w. Only one unit is allowed, for example: 2w3d is not allowed; you should use 17d instead. - pub fn window(mut self, new_value: &str) -> TimeseryListCall<'a, C, NC, A> { + pub fn window(mut self, new_value: &str) -> TimeseryListCall<'a, C, A> { self._window = Some(new_value.to_string()); self } @@ -1962,7 +1958,7 @@ impl<'a, C, NC, A> TimeseryListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// - w: week Examples: 2s, 3m, 4w. Only one unit is allowed, for example: 2w3d is not allowed; you should use 17d instead. /// /// If neither oldest nor timespan is specified, the default time interval will be (youngest - 4 hours, youngest]. - pub fn timespan(mut self, new_value: &str) -> TimeseryListCall<'a, C, NC, A> { + pub fn timespan(mut self, new_value: &str) -> TimeseryListCall<'a, C, A> { self._timespan = Some(new_value.to_string()); self } @@ -1970,7 +1966,7 @@ impl<'a, C, NC, A> TimeseryListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The pagination token, which is used to page through large result sets. Set this value to the value of the nextPageToken to retrieve the next page of results. - pub fn page_token(mut self, new_value: &str) -> TimeseryListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TimeseryListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -1978,7 +1974,7 @@ impl<'a, C, NC, A> TimeseryListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Start of the time interval (exclusive), which is expressed as an RFC 3339 timestamp. If neither oldest nor timespan is specified, the default time interval will be (youngest - 4 hours, youngest] - pub fn oldest(mut self, new_value: &str) -> TimeseryListCall<'a, C, NC, A> { + pub fn oldest(mut self, new_value: &str) -> TimeseryListCall<'a, C, A> { self._oldest = Some(new_value.to_string()); self } @@ -1992,7 +1988,7 @@ impl<'a, C, NC, A> TimeseryListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// - key!=value: key does not equal the value /// - key!~value: key regex does not match the value For example, to list all of the time series descriptors for the region us-central1, you could specify: /// label=cloud.googleapis.com%2Flocation=~us-central1.* - pub fn add_labels(mut self, new_value: &str) -> TimeseryListCall<'a, C, NC, A> { + pub fn add_labels(mut self, new_value: &str) -> TimeseryListCall<'a, C, A> { self._labels.push(new_value.to_string()); self } @@ -2000,7 +1996,7 @@ impl<'a, C, NC, A> TimeseryListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Maximum number of data points per page, which is used for pagination of results. - pub fn count(mut self, new_value: i32) -> TimeseryListCall<'a, C, NC, A> { + pub fn count(mut self, new_value: i32) -> TimeseryListCall<'a, C, A> { self._count = Some(new_value); self } @@ -2008,7 +2004,7 @@ impl<'a, C, NC, A> TimeseryListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The aggregation function that will reduce the data points in each window to a single point. This parameter is only valid for non-cumulative metrics with a value type of INT64 or DOUBLE. - pub fn aggregator(mut self, new_value: &str) -> TimeseryListCall<'a, C, NC, A> { + pub fn aggregator(mut self, new_value: &str) -> TimeseryListCall<'a, C, A> { self._aggregator = Some(new_value.to_string()); self } @@ -2019,7 +2015,7 @@ impl<'a, C, NC, A> TimeseryListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimeseryListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimeseryListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2040,7 +2036,7 @@ impl<'a, C, NC, A> TimeseryListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TimeseryListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TimeseryListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2057,7 +2053,7 @@ impl<'a, C, NC, A> TimeseryListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TimeseryListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TimeseryListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2104,10 +2100,10 @@ impl<'a, C, NC, A> TimeseryListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct MetricDescriptorListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MetricDescriptorListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CloudMonitoring, + hub: &'a CloudMonitoring, _request: ListMetricDescriptorsRequest, _project: String, _query: Option, @@ -2118,9 +2114,9 @@ pub struct MetricDescriptorListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MetricDescriptorListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MetricDescriptorListCall<'a, C, A> {} -impl<'a, C, NC, A> MetricDescriptorListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MetricDescriptorListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2268,7 +2264,7 @@ impl<'a, C, NC, A> MetricDescriptorListCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ListMetricDescriptorsRequest) -> MetricDescriptorListCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ListMetricDescriptorsRequest) -> MetricDescriptorListCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2278,7 +2274,7 @@ impl<'a, C, NC, A> MetricDescriptorListCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The project id. The value can be the numeric project ID or string-based project name. - pub fn project(mut self, new_value: &str) -> MetricDescriptorListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> MetricDescriptorListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2286,7 +2282,7 @@ impl<'a, C, NC, A> MetricDescriptorListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// The query used to search against existing metrics. Separate keywords with a space; the service joins all keywords with AND, meaning that all keywords must match for a metric to be returned. If this field is omitted, all metrics are returned. If an empty string is passed with this field, no metrics are returned. - pub fn query(mut self, new_value: &str) -> MetricDescriptorListCall<'a, C, NC, A> { + pub fn query(mut self, new_value: &str) -> MetricDescriptorListCall<'a, C, A> { self._query = Some(new_value.to_string()); self } @@ -2294,7 +2290,7 @@ impl<'a, C, NC, A> MetricDescriptorListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// The pagination token, which is used to page through large result sets. Set this value to the value of the nextPageToken to retrieve the next page of results. - pub fn page_token(mut self, new_value: &str) -> MetricDescriptorListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> MetricDescriptorListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2302,7 +2298,7 @@ impl<'a, C, NC, A> MetricDescriptorListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// Maximum number of metric descriptors per page. Used for pagination. If not specified, count = 100. - pub fn count(mut self, new_value: i32) -> MetricDescriptorListCall<'a, C, NC, A> { + pub fn count(mut self, new_value: i32) -> MetricDescriptorListCall<'a, C, A> { self._count = Some(new_value); self } @@ -2313,7 +2309,7 @@ impl<'a, C, NC, A> MetricDescriptorListCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MetricDescriptorListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MetricDescriptorListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2334,7 +2330,7 @@ impl<'a, C, NC, A> MetricDescriptorListCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MetricDescriptorListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MetricDescriptorListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2351,7 +2347,7 @@ impl<'a, C, NC, A> MetricDescriptorListCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MetricDescriptorListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MetricDescriptorListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2389,10 +2385,10 @@ impl<'a, C, NC, A> MetricDescriptorListCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct MetricDescriptorDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MetricDescriptorDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CloudMonitoring, + hub: &'a CloudMonitoring, _project: String, _metric: String, _delegate: Option<&'a mut Delegate>, @@ -2400,9 +2396,9 @@ pub struct MetricDescriptorDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MetricDescriptorDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MetricDescriptorDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> MetricDescriptorDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MetricDescriptorDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2535,7 +2531,7 @@ impl<'a, C, NC, A> MetricDescriptorDeleteCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The project ID to which the metric belongs. - pub fn project(mut self, new_value: &str) -> MetricDescriptorDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> MetricDescriptorDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2545,7 +2541,7 @@ impl<'a, C, NC, A> MetricDescriptorDeleteCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Name of the metric. - pub fn metric(mut self, new_value: &str) -> MetricDescriptorDeleteCall<'a, C, NC, A> { + pub fn metric(mut self, new_value: &str) -> MetricDescriptorDeleteCall<'a, C, A> { self._metric = new_value.to_string(); self } @@ -2556,7 +2552,7 @@ impl<'a, C, NC, A> MetricDescriptorDeleteCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MetricDescriptorDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MetricDescriptorDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2577,7 +2573,7 @@ impl<'a, C, NC, A> MetricDescriptorDeleteCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MetricDescriptorDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MetricDescriptorDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2594,7 +2590,7 @@ impl<'a, C, NC, A> MetricDescriptorDeleteCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MetricDescriptorDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MetricDescriptorDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2638,10 +2634,10 @@ impl<'a, C, NC, A> MetricDescriptorDeleteCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct MetricDescriptorCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MetricDescriptorCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a CloudMonitoring, + hub: &'a CloudMonitoring, _request: MetricDescriptor, _project: String, _delegate: Option<&'a mut Delegate>, @@ -2649,9 +2645,9 @@ pub struct MetricDescriptorCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MetricDescriptorCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MetricDescriptorCreateCall<'a, C, A> {} -impl<'a, C, NC, A> MetricDescriptorCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MetricDescriptorCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2790,7 +2786,7 @@ impl<'a, C, NC, A> MetricDescriptorCreateCall<'a, C, NC, A> where NC: hyper::net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &MetricDescriptor) -> MetricDescriptorCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &MetricDescriptor) -> MetricDescriptorCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2800,7 +2796,7 @@ impl<'a, C, NC, A> MetricDescriptorCreateCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The project id. The value can be the numeric project ID or string-based project name. - pub fn project(mut self, new_value: &str) -> MetricDescriptorCreateCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> MetricDescriptorCreateCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2811,7 +2807,7 @@ impl<'a, C, NC, A> MetricDescriptorCreateCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MetricDescriptorCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MetricDescriptorCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2832,7 +2828,7 @@ impl<'a, C, NC, A> MetricDescriptorCreateCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MetricDescriptorCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MetricDescriptorCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2849,7 +2845,7 @@ impl<'a, C, NC, A> MetricDescriptorCreateCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MetricDescriptorCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MetricDescriptorCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/cloudsearch1/Cargo.toml b/gen/cloudsearch1/Cargo.toml index 1079811d542..408f4070227 100644 --- a/gen/cloudsearch1/Cargo.toml +++ b/gen/cloudsearch1/Cargo.toml @@ -4,11 +4,11 @@ [package] name = "google-cloudsearch1" -version = "0.1.4+20150309" +version = "0.1.5+20150309" authors = ["Sebastian Thiel "] description = "A complete library to interact with cloudsearch (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/cloudsearch1" -documentation = "http://byron.github.io/google-apis-rs/google-cloudsearch1" +documentation = "http://byron.github.io/google-apis-rs/google_cloudsearch1" license = "MIT" keywords = ["cloudsearch", "google", "protocol", "web", "api"] diff --git a/gen/cloudsearch1/README.md b/gen/cloudsearch1/README.md index 17025d230b2..f733fd5fbff 100644 --- a/gen/cloudsearch1/README.md +++ b/gen/cloudsearch1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-cloudsearch1` library allows access to all features of the *Google cloudsearch* service. -This documentation was generated from *cloudsearch* crate version *0.1.4+20150309*, where *20150309* is the exact revision of the *cloudsearch:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *cloudsearch* crate version *0.1.5+20150309*, where *20150309* is the exact revision of the *cloudsearch:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. # Features Handle the following *Resources* with ease from the central [hub](http://byron.github.io/google-apis-rs/google-cloudsearch1/struct.Cloudsearch.html) ... diff --git a/gen/cloudsearch1/src/cmn.rs b/gen/cloudsearch1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/cloudsearch1/src/cmn.rs +++ b/gen/cloudsearch1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/cloudsearch1/src/lib.rs b/gen/cloudsearch1/src/lib.rs index 1b109ffc09c..7f226b85651 100644 --- a/gen/cloudsearch1/src/lib.rs +++ b/gen/cloudsearch1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *cloudsearch* crate version *0.1.4+20150309*, where *20150309* is the exact revision of the *cloudsearch:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *cloudsearch* crate version *0.1.5+20150309*, where *20150309* is the exact revision of the *cloudsearch:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/master/gen/cloudsearch1). //! # Features //! @@ -186,7 +186,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -285,34 +284,31 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Cloudsearch { +pub struct Cloudsearch { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Cloudsearch {} +impl<'a, C, A> Hub for Cloudsearch {} -impl<'a, C, NC, A> Cloudsearch - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Cloudsearch + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Cloudsearch { + pub fn new(client: C, authenticator: A) -> Cloudsearch { Cloudsearch { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn projects(&'a self) -> ProjectMethods<'a, C, NC, A> { + pub fn projects(&'a self) -> ProjectMethods<'a, C, A> { ProjectMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -571,15 +567,15 @@ impl ResponseResult for Empty {} /// let rb = hub.projects(); /// # } /// ``` -pub struct ProjectMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Cloudsearch, + hub: &'a Cloudsearch, } -impl<'a, C, NC, A> MethodsBuilder for ProjectMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ProjectMethods<'a, C, A> {} -impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { +impl<'a, C, A> ProjectMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -592,7 +588,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// * `pageSize` - The maximum number of indexes to return per page. If not specified, 100 indexes are returned per page. /// * `pageToken` - A `nextPageToken` returned from previous list indexes call as the starting point for this call. If not specified, list indexes from the beginning. /// * `view` - Specifies which parts of the IndexInfo resource is returned in the response. If not specified, `ID_ONLY` is used. - pub fn indexes_list(&self, project_id: &str, index_name_prefix: &str, page_size: i32, page_token: &str, view: &str) -> ProjectIndexeListCall<'a, C, NC, A> { + pub fn indexes_list(&self, project_id: &str, index_name_prefix: &str, page_size: i32, page_token: &str, view: &str) -> ProjectIndexeListCall<'a, C, A> { ProjectIndexeListCall { hub: self.hub, _project_id: project_id.to_string(), @@ -615,7 +611,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// * `projectId` - The project associated with the index for retrieving the document. It cannot be the empty string. /// * `indexId` - The index from which to retrieve the document. It cannot be the empty string. /// * `docId` - The identifier of the document to retrieve. It cannot be the empty string. - pub fn indexes_documents_get(&self, project_id: &str, index_id: &str, doc_id: &str) -> ProjectIndexeDocumentGetCall<'a, C, NC, A> { + pub fn indexes_documents_get(&self, project_id: &str, index_id: &str, doc_id: &str) -> ProjectIndexeDocumentGetCall<'a, C, A> { ProjectIndexeDocumentGetCall { hub: self.hub, _project_id: project_id.to_string(), @@ -645,7 +641,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// * `scorer` - The scoring function to invoke on a search result for this query. If `scorer` is not set, scoring is disabled and `_score` is 0 for all documents in the search result. To enable document relevancy score based on term frequency, set `"scorer=generic"`. /// * `scorerSize` - Maximum number of top retrieved results to score. It is valid only when `scorer` is set. If not specified, 100 retrieved results are scored. /// * `returnFields` - List of fields to return in `SearchResult` objects. It can be fields from `Document`, the built-in fields `_rank` and `_score`, and fields defined in `fieldExpressions`. Use `"*"` to return all fields from `Document`. - pub fn indexes_search(&self, project_id: &str, index_id: &str, query: &str, field_expressions: &Vec, page_size: i32, page_token: &str, offset: i32, matched_count_accuracy: i32, order_by: &str, scorer: &str, scorer_size: i32, return_fields: &Vec) -> ProjectIndexeSearchCall<'a, C, NC, A> { + pub fn indexes_search(&self, project_id: &str, index_id: &str, query: &str, field_expressions: &Vec, page_size: i32, page_token: &str, offset: i32, matched_count_accuracy: i32, order_by: &str, scorer: &str, scorer_size: i32, return_fields: &Vec) -> ProjectIndexeSearchCall<'a, C, A> { ProjectIndexeSearchCall { hub: self.hub, _project_id: project_id.to_string(), @@ -677,7 +673,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// * `pageSize` - The maximum number of documents to return per page. If not specified, 100 documents are returned per page. /// * `pageToken` - A `nextPageToken` returned from previous list documents call as the starting point for this call. If not specified, list documents from the beginning. /// * `view` - Specifies which part of the document resource is returned in the response. If not specified, `ID_ONLY` is used. - pub fn indexes_documents_list(&self, project_id: &str, index_id: &str, page_size: i32, page_token: &str, view: &str) -> ProjectIndexeDocumentListCall<'a, C, NC, A> { + pub fn indexes_documents_list(&self, project_id: &str, index_id: &str, page_size: i32, page_token: &str, view: &str) -> ProjectIndexeDocumentListCall<'a, C, A> { ProjectIndexeDocumentListCall { hub: self.hub, _project_id: project_id.to_string(), @@ -700,7 +696,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `projectId` - The project associated with the index for adding document. It cannot be the empty string. /// * `indexId` - The index to add document to. It cannot be the empty string. - pub fn indexes_documents_create(&self, request: &Document, project_id: &str, index_id: &str) -> ProjectIndexeDocumentCreateCall<'a, C, NC, A> { + pub fn indexes_documents_create(&self, request: &Document, project_id: &str, index_id: &str) -> ProjectIndexeDocumentCreateCall<'a, C, A> { ProjectIndexeDocumentCreateCall { hub: self.hub, _request: request.clone(), @@ -721,7 +717,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// * `projectId` - The project associated with the index for deleting document. It cannot be the empty string. /// * `indexId` - The index from which to delete the document. It cannot be the empty string. /// * `docId` - The document to be deleted. It cannot be the empty string. - pub fn indexes_documents_delete(&self, project_id: &str, index_id: &str, doc_id: &str) -> ProjectIndexeDocumentDeleteCall<'a, C, NC, A> { + pub fn indexes_documents_delete(&self, project_id: &str, index_id: &str, doc_id: &str) -> ProjectIndexeDocumentDeleteCall<'a, C, A> { ProjectIndexeDocumentDeleteCall { hub: self.hub, _project_id: project_id.to_string(), @@ -772,10 +768,10 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct ProjectIndexeListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectIndexeListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Cloudsearch, + hub: &'a Cloudsearch, _project_id: String, _index_name_prefix: String, _page_size: i32, @@ -786,9 +782,9 @@ pub struct ProjectIndexeListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectIndexeListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectIndexeListCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectIndexeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectIndexeListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -924,7 +920,7 @@ impl<'a, C, NC, A> ProjectIndexeListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The project from which to retrieve indexes. It cannot be the empty string. - pub fn project_id(mut self, new_value: &str) -> ProjectIndexeListCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> ProjectIndexeListCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -934,7 +930,7 @@ impl<'a, C, NC, A> ProjectIndexeListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The prefix of the index name. It is used to list all indexes with names that have this prefix. - pub fn index_name_prefix(mut self, new_value: &str) -> ProjectIndexeListCall<'a, C, NC, A> { + pub fn index_name_prefix(mut self, new_value: &str) -> ProjectIndexeListCall<'a, C, A> { self._index_name_prefix = new_value.to_string(); self } @@ -944,7 +940,7 @@ impl<'a, C, NC, A> ProjectIndexeListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The maximum number of indexes to return per page. If not specified, 100 indexes are returned per page. - pub fn page_size(mut self, new_value: i32) -> ProjectIndexeListCall<'a, C, NC, A> { + pub fn page_size(mut self, new_value: i32) -> ProjectIndexeListCall<'a, C, A> { self._page_size = new_value; self } @@ -954,7 +950,7 @@ impl<'a, C, NC, A> ProjectIndexeListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// A `nextPageToken` returned from previous list indexes call as the starting point for this call. If not specified, list indexes from the beginning. - pub fn page_token(mut self, new_value: &str) -> ProjectIndexeListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ProjectIndexeListCall<'a, C, A> { self._page_token = new_value.to_string(); self } @@ -964,7 +960,7 @@ impl<'a, C, NC, A> ProjectIndexeListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Specifies which parts of the IndexInfo resource is returned in the response. If not specified, `ID_ONLY` is used. - pub fn view(mut self, new_value: &str) -> ProjectIndexeListCall<'a, C, NC, A> { + pub fn view(mut self, new_value: &str) -> ProjectIndexeListCall<'a, C, A> { self._view = new_value.to_string(); self } @@ -975,7 +971,7 @@ impl<'a, C, NC, A> ProjectIndexeListCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectIndexeListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectIndexeListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1000,7 +996,7 @@ impl<'a, C, NC, A> ProjectIndexeListCall<'a, C, NC, A> where NC: hyper::net::Net /// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. /// * *alt* (query-string) - Data format for response. /// * *$.xgafv* (query-string) - V1 error format. - pub fn param(mut self, name: T, value: T) -> ProjectIndexeListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectIndexeListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1017,7 +1013,7 @@ impl<'a, C, NC, A> ProjectIndexeListCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectIndexeListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectIndexeListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1055,10 +1051,10 @@ impl<'a, C, NC, A> ProjectIndexeListCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct ProjectIndexeDocumentGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectIndexeDocumentGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Cloudsearch, + hub: &'a Cloudsearch, _project_id: String, _index_id: String, _doc_id: String, @@ -1067,9 +1063,9 @@ pub struct ProjectIndexeDocumentGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectIndexeDocumentGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectIndexeDocumentGetCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectIndexeDocumentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectIndexeDocumentGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1203,7 +1199,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentGetCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The project associated with the index for retrieving the document. It cannot be the empty string. - pub fn project_id(mut self, new_value: &str) -> ProjectIndexeDocumentGetCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> ProjectIndexeDocumentGetCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -1213,7 +1209,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentGetCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The index from which to retrieve the document. It cannot be the empty string. - pub fn index_id(mut self, new_value: &str) -> ProjectIndexeDocumentGetCall<'a, C, NC, A> { + pub fn index_id(mut self, new_value: &str) -> ProjectIndexeDocumentGetCall<'a, C, A> { self._index_id = new_value.to_string(); self } @@ -1223,7 +1219,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentGetCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The identifier of the document to retrieve. It cannot be the empty string. - pub fn doc_id(mut self, new_value: &str) -> ProjectIndexeDocumentGetCall<'a, C, NC, A> { + pub fn doc_id(mut self, new_value: &str) -> ProjectIndexeDocumentGetCall<'a, C, A> { self._doc_id = new_value.to_string(); self } @@ -1234,7 +1230,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentGetCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectIndexeDocumentGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectIndexeDocumentGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1259,7 +1255,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentGetCall<'a, C, NC, A> where NC: hyper::n /// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. /// * *alt* (query-string) - Data format for response. /// * *$.xgafv* (query-string) - V1 error format. - pub fn param(mut self, name: T, value: T) -> ProjectIndexeDocumentGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectIndexeDocumentGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1276,7 +1272,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentGetCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectIndexeDocumentGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectIndexeDocumentGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1314,10 +1310,10 @@ impl<'a, C, NC, A> ProjectIndexeDocumentGetCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct ProjectIndexeSearchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectIndexeSearchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Cloudsearch, + hub: &'a Cloudsearch, _project_id: String, _index_id: String, _query: String, @@ -1335,9 +1331,9 @@ pub struct ProjectIndexeSearchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectIndexeSearchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectIndexeSearchCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectIndexeSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectIndexeSearchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1492,7 +1488,7 @@ impl<'a, C, NC, A> ProjectIndexeSearchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The project associated with the index for searching document. It cannot be the empty string. - pub fn project_id(mut self, new_value: &str) -> ProjectIndexeSearchCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> ProjectIndexeSearchCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -1502,7 +1498,7 @@ impl<'a, C, NC, A> ProjectIndexeSearchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The index to search. It cannot be the empty string. - pub fn index_id(mut self, new_value: &str) -> ProjectIndexeSearchCall<'a, C, NC, A> { + pub fn index_id(mut self, new_value: &str) -> ProjectIndexeSearchCall<'a, C, A> { self._index_id = new_value.to_string(); self } @@ -1512,7 +1508,7 @@ impl<'a, C, NC, A> ProjectIndexeSearchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The query string in search query syntax. If the query is missing or empty, all documents are returned. - pub fn query(mut self, new_value: &str) -> ProjectIndexeSearchCall<'a, C, NC, A> { + pub fn query(mut self, new_value: &str) -> ProjectIndexeSearchCall<'a, C, A> { self._query = new_value.to_string(); self } @@ -1523,7 +1519,7 @@ impl<'a, C, NC, A> ProjectIndexeSearchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Customized expressions used in `orderBy` or `returnFields`. The expression can contain fields in `Document`, the built-in fields ( `_rank`, the document rank, and `_score` if scoring is enabled) and fields defined in `fieldExpressions`. Each field expression is represented in a json object with the following fields: * `name`: the name of the field expression in string. * `expression`: the expression to be computed. It can be a combination of supported functions encoded in string. Expressions involving number fields can use the arithmetical operators (`+`, `-`, `*`, `/`) and the built-in numeric functions (`max`, `min`, `pow`, `count`, `log`, `abs`). Expressions involving geopoint fields can use the `geopoint` and `distance` functions. Expressions for text and html fields can use the `snippet` function. For example: ``` fieldExpressions={name: "TotalPrice", expression: "(Price+Tax)"} ``` ``` fieldExpressions={name: "snippet", expression: "snippet('good times', content)"} ``` The field expression names can be used in `orderBy` and `returnFields` after they are defined in `fieldExpressions`. - pub fn add_field_expressions(mut self, new_value: &str) -> ProjectIndexeSearchCall<'a, C, NC, A> { + pub fn add_field_expressions(mut self, new_value: &str) -> ProjectIndexeSearchCall<'a, C, A> { self._field_expressions.push(new_value.to_string()); self } @@ -1533,7 +1529,7 @@ impl<'a, C, NC, A> ProjectIndexeSearchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The maximum number of search results to return per page. Searches perform best when the `pageSize` is kept as small as possible. If not specified, 10 results are returned per page. - pub fn page_size(mut self, new_value: i32) -> ProjectIndexeSearchCall<'a, C, NC, A> { + pub fn page_size(mut self, new_value: i32) -> ProjectIndexeSearchCall<'a, C, A> { self._page_size = new_value; self } @@ -1543,7 +1539,7 @@ impl<'a, C, NC, A> ProjectIndexeSearchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// A `nextPageToken` returned from previous Search call as the starting point for this call. Pagination tokens provide better performance and consistency than offsets, and they cannot be used in combination with offsets. - pub fn page_token(mut self, new_value: &str) -> ProjectIndexeSearchCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ProjectIndexeSearchCall<'a, C, A> { self._page_token = new_value.to_string(); self } @@ -1553,7 +1549,7 @@ impl<'a, C, NC, A> ProjectIndexeSearchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Offset is used to move to an arbitrary result, independent of the previous results. Offsets are inefficient when compared to `pageToken`. `pageToken` and `offset` cannot be both set. The default value of `offset` is 0. - pub fn offset(mut self, new_value: i32) -> ProjectIndexeSearchCall<'a, C, NC, A> { + pub fn offset(mut self, new_value: i32) -> ProjectIndexeSearchCall<'a, C, A> { self._offset = new_value; self } @@ -1563,7 +1559,7 @@ impl<'a, C, NC, A> ProjectIndexeSearchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Minimum accuracy requirement for `matchedCount` in search response. If specified, `matchedCount` will be accurate up to at least that number. For example, when set to 100, any `matchedCount <= 100` is accurate. This option may add considerable latency/expense. By default (when it is not specified or set to 0), the accuracy is the same as `pageSize`. - pub fn matched_count_accuracy(mut self, new_value: i32) -> ProjectIndexeSearchCall<'a, C, NC, A> { + pub fn matched_count_accuracy(mut self, new_value: i32) -> ProjectIndexeSearchCall<'a, C, A> { self._matched_count_accuracy = new_value; self } @@ -1573,7 +1569,7 @@ impl<'a, C, NC, A> ProjectIndexeSearchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Comma-separated list of fields for sorting on the search result, including fields from `Document`, the built-in fields (`_rank` and `_score`), and fields defined in `fieldExpressions`. For example: `orderBy="foo,bar"`. The default sorting order is ascending. To specify descending order for a field, a suffix `" desc"` should be appended to the field name. For example: `orderBy="foo desc,bar"`. The default value for text sort is the empty string, and the default value for numeric sort is 0. If not specified, the search results are automatically sorted by descending `_rank`. Sorting by ascending `_rank` is not allowed. - pub fn order_by(mut self, new_value: &str) -> ProjectIndexeSearchCall<'a, C, NC, A> { + pub fn order_by(mut self, new_value: &str) -> ProjectIndexeSearchCall<'a, C, A> { self._order_by = new_value.to_string(); self } @@ -1583,7 +1579,7 @@ impl<'a, C, NC, A> ProjectIndexeSearchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The scoring function to invoke on a search result for this query. If `scorer` is not set, scoring is disabled and `_score` is 0 for all documents in the search result. To enable document relevancy score based on term frequency, set `"scorer=generic"`. - pub fn scorer(mut self, new_value: &str) -> ProjectIndexeSearchCall<'a, C, NC, A> { + pub fn scorer(mut self, new_value: &str) -> ProjectIndexeSearchCall<'a, C, A> { self._scorer = new_value.to_string(); self } @@ -1593,7 +1589,7 @@ impl<'a, C, NC, A> ProjectIndexeSearchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Maximum number of top retrieved results to score. It is valid only when `scorer` is set. If not specified, 100 retrieved results are scored. - pub fn scorer_size(mut self, new_value: i32) -> ProjectIndexeSearchCall<'a, C, NC, A> { + pub fn scorer_size(mut self, new_value: i32) -> ProjectIndexeSearchCall<'a, C, A> { self._scorer_size = new_value; self } @@ -1604,7 +1600,7 @@ impl<'a, C, NC, A> ProjectIndexeSearchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// List of fields to return in `SearchResult` objects. It can be fields from `Document`, the built-in fields `_rank` and `_score`, and fields defined in `fieldExpressions`. Use `"*"` to return all fields from `Document`. - pub fn add_return_fields(mut self, new_value: &str) -> ProjectIndexeSearchCall<'a, C, NC, A> { + pub fn add_return_fields(mut self, new_value: &str) -> ProjectIndexeSearchCall<'a, C, A> { self._return_fields.push(new_value.to_string()); self } @@ -1615,7 +1611,7 @@ impl<'a, C, NC, A> ProjectIndexeSearchCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectIndexeSearchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectIndexeSearchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1640,7 +1636,7 @@ impl<'a, C, NC, A> ProjectIndexeSearchCall<'a, C, NC, A> where NC: hyper::net::N /// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. /// * *alt* (query-string) - Data format for response. /// * *$.xgafv* (query-string) - V1 error format. - pub fn param(mut self, name: T, value: T) -> ProjectIndexeSearchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectIndexeSearchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1657,7 +1653,7 @@ impl<'a, C, NC, A> ProjectIndexeSearchCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectIndexeSearchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectIndexeSearchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1695,10 +1691,10 @@ impl<'a, C, NC, A> ProjectIndexeSearchCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct ProjectIndexeDocumentListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectIndexeDocumentListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Cloudsearch, + hub: &'a Cloudsearch, _project_id: String, _index_id: String, _page_size: i32, @@ -1709,9 +1705,9 @@ pub struct ProjectIndexeDocumentListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectIndexeDocumentListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectIndexeDocumentListCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectIndexeDocumentListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectIndexeDocumentListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1847,7 +1843,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentListCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The project associated with the index for listing documents. It cannot be the empty string. - pub fn project_id(mut self, new_value: &str) -> ProjectIndexeDocumentListCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> ProjectIndexeDocumentListCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -1857,7 +1853,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentListCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The index from which to list the documents. It cannot be the empty string. - pub fn index_id(mut self, new_value: &str) -> ProjectIndexeDocumentListCall<'a, C, NC, A> { + pub fn index_id(mut self, new_value: &str) -> ProjectIndexeDocumentListCall<'a, C, A> { self._index_id = new_value.to_string(); self } @@ -1867,7 +1863,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentListCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The maximum number of documents to return per page. If not specified, 100 documents are returned per page. - pub fn page_size(mut self, new_value: i32) -> ProjectIndexeDocumentListCall<'a, C, NC, A> { + pub fn page_size(mut self, new_value: i32) -> ProjectIndexeDocumentListCall<'a, C, A> { self._page_size = new_value; self } @@ -1877,7 +1873,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentListCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// A `nextPageToken` returned from previous list documents call as the starting point for this call. If not specified, list documents from the beginning. - pub fn page_token(mut self, new_value: &str) -> ProjectIndexeDocumentListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ProjectIndexeDocumentListCall<'a, C, A> { self._page_token = new_value.to_string(); self } @@ -1887,7 +1883,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentListCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Specifies which part of the document resource is returned in the response. If not specified, `ID_ONLY` is used. - pub fn view(mut self, new_value: &str) -> ProjectIndexeDocumentListCall<'a, C, NC, A> { + pub fn view(mut self, new_value: &str) -> ProjectIndexeDocumentListCall<'a, C, A> { self._view = new_value.to_string(); self } @@ -1898,7 +1894,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentListCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectIndexeDocumentListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectIndexeDocumentListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1923,7 +1919,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentListCall<'a, C, NC, A> where NC: hyper:: /// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. /// * *alt* (query-string) - Data format for response. /// * *$.xgafv* (query-string) - V1 error format. - pub fn param(mut self, name: T, value: T) -> ProjectIndexeDocumentListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectIndexeDocumentListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1940,7 +1936,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentListCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectIndexeDocumentListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectIndexeDocumentListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1984,10 +1980,10 @@ impl<'a, C, NC, A> ProjectIndexeDocumentListCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct ProjectIndexeDocumentCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectIndexeDocumentCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Cloudsearch, + hub: &'a Cloudsearch, _request: Document, _project_id: String, _index_id: String, @@ -1996,9 +1992,9 @@ pub struct ProjectIndexeDocumentCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectIndexeDocumentCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectIndexeDocumentCreateCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectIndexeDocumentCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectIndexeDocumentCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2138,7 +2134,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentCreateCall<'a, C, NC, A> where NC: hyper /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Document) -> ProjectIndexeDocumentCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Document) -> ProjectIndexeDocumentCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2148,7 +2144,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentCreateCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The project associated with the index for adding document. It cannot be the empty string. - pub fn project_id(mut self, new_value: &str) -> ProjectIndexeDocumentCreateCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> ProjectIndexeDocumentCreateCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -2158,7 +2154,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentCreateCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The index to add document to. It cannot be the empty string. - pub fn index_id(mut self, new_value: &str) -> ProjectIndexeDocumentCreateCall<'a, C, NC, A> { + pub fn index_id(mut self, new_value: &str) -> ProjectIndexeDocumentCreateCall<'a, C, A> { self._index_id = new_value.to_string(); self } @@ -2169,7 +2165,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentCreateCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectIndexeDocumentCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectIndexeDocumentCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2194,7 +2190,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentCreateCall<'a, C, NC, A> where NC: hyper /// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. /// * *alt* (query-string) - Data format for response. /// * *$.xgafv* (query-string) - V1 error format. - pub fn param(mut self, name: T, value: T) -> ProjectIndexeDocumentCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectIndexeDocumentCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2211,7 +2207,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentCreateCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectIndexeDocumentCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectIndexeDocumentCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2249,10 +2245,10 @@ impl<'a, C, NC, A> ProjectIndexeDocumentCreateCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct ProjectIndexeDocumentDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectIndexeDocumentDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Cloudsearch, + hub: &'a Cloudsearch, _project_id: String, _index_id: String, _doc_id: String, @@ -2261,9 +2257,9 @@ pub struct ProjectIndexeDocumentDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectIndexeDocumentDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectIndexeDocumentDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectIndexeDocumentDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectIndexeDocumentDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2397,7 +2393,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentDeleteCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The project associated with the index for deleting document. It cannot be the empty string. - pub fn project_id(mut self, new_value: &str) -> ProjectIndexeDocumentDeleteCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> ProjectIndexeDocumentDeleteCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -2407,7 +2403,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentDeleteCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The index from which to delete the document. It cannot be the empty string. - pub fn index_id(mut self, new_value: &str) -> ProjectIndexeDocumentDeleteCall<'a, C, NC, A> { + pub fn index_id(mut self, new_value: &str) -> ProjectIndexeDocumentDeleteCall<'a, C, A> { self._index_id = new_value.to_string(); self } @@ -2417,7 +2413,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentDeleteCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The document to be deleted. It cannot be the empty string. - pub fn doc_id(mut self, new_value: &str) -> ProjectIndexeDocumentDeleteCall<'a, C, NC, A> { + pub fn doc_id(mut self, new_value: &str) -> ProjectIndexeDocumentDeleteCall<'a, C, A> { self._doc_id = new_value.to_string(); self } @@ -2428,7 +2424,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentDeleteCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectIndexeDocumentDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectIndexeDocumentDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2453,7 +2449,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentDeleteCall<'a, C, NC, A> where NC: hyper /// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. /// * *alt* (query-string) - Data format for response. /// * *$.xgafv* (query-string) - V1 error format. - pub fn param(mut self, name: T, value: T) -> ProjectIndexeDocumentDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectIndexeDocumentDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2470,7 +2466,7 @@ impl<'a, C, NC, A> ProjectIndexeDocumentDeleteCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectIndexeDocumentDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectIndexeDocumentDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/compute1/Cargo.toml b/gen/compute1/Cargo.toml index f66457772bf..6da71517c2c 100644 --- a/gen/compute1/Cargo.toml +++ b/gen/compute1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-compute1" -version = "0.1.4+20150326" +version = "0.1.5+20150326" authors = ["Sebastian Thiel "] description = "A complete library to interact with compute (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/compute1" homepage = "https://developers.google.com/compute/docs/reference/latest/" -documentation = "http://byron.github.io/google-apis-rs/google-compute1" +documentation = "http://byron.github.io/google-apis-rs/google_compute1" license = "MIT" keywords = ["compute", "google", "protocol", "web", "api"] diff --git a/gen/compute1/README.md b/gen/compute1/README.md index 7713ad6c30a..f128643c02d 100644 --- a/gen/compute1/README.md +++ b/gen/compute1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-compute1` library allows access to all features of the *Google compute* service. -This documentation was generated from *compute* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *compute:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *compute* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *compute:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *compute* *v1* API can be found at the [official documentation site](https://developers.google.com/compute/docs/reference/latest/). diff --git a/gen/compute1/src/cmn.rs b/gen/compute1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/compute1/src/cmn.rs +++ b/gen/compute1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/compute1/src/lib.rs b/gen/compute1/src/lib.rs index 249d7e4a010..527e187e56c 100644 --- a/gen/compute1/src/lib.rs +++ b/gen/compute1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *compute* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *compute:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *compute* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *compute:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *compute* *v1* API can be found at the //! [official documentation site](https://developers.google.com/compute/docs/reference/latest/). @@ -318,7 +318,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -429,118 +428,115 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Compute { +pub struct Compute { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Compute {} +impl<'a, C, A> Hub for Compute {} -impl<'a, C, NC, A> Compute - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Compute + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Compute { + pub fn new(client: C, authenticator: A) -> Compute { Compute { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn addresses(&'a self) -> AddresseMethods<'a, C, NC, A> { + pub fn addresses(&'a self) -> AddresseMethods<'a, C, A> { AddresseMethods { hub: &self } } - pub fn backend_services(&'a self) -> BackendServiceMethods<'a, C, NC, A> { + pub fn backend_services(&'a self) -> BackendServiceMethods<'a, C, A> { BackendServiceMethods { hub: &self } } - pub fn disk_types(&'a self) -> DiskTypeMethods<'a, C, NC, A> { + pub fn disk_types(&'a self) -> DiskTypeMethods<'a, C, A> { DiskTypeMethods { hub: &self } } - pub fn disks(&'a self) -> DiskMethods<'a, C, NC, A> { + pub fn disks(&'a self) -> DiskMethods<'a, C, A> { DiskMethods { hub: &self } } - pub fn firewalls(&'a self) -> FirewallMethods<'a, C, NC, A> { + pub fn firewalls(&'a self) -> FirewallMethods<'a, C, A> { FirewallMethods { hub: &self } } - pub fn forwarding_rules(&'a self) -> ForwardingRuleMethods<'a, C, NC, A> { + pub fn forwarding_rules(&'a self) -> ForwardingRuleMethods<'a, C, A> { ForwardingRuleMethods { hub: &self } } - pub fn global_addresses(&'a self) -> GlobalAddresseMethods<'a, C, NC, A> { + pub fn global_addresses(&'a self) -> GlobalAddresseMethods<'a, C, A> { GlobalAddresseMethods { hub: &self } } - pub fn global_forwarding_rules(&'a self) -> GlobalForwardingRuleMethods<'a, C, NC, A> { + pub fn global_forwarding_rules(&'a self) -> GlobalForwardingRuleMethods<'a, C, A> { GlobalForwardingRuleMethods { hub: &self } } - pub fn global_operations(&'a self) -> GlobalOperationMethods<'a, C, NC, A> { + pub fn global_operations(&'a self) -> GlobalOperationMethods<'a, C, A> { GlobalOperationMethods { hub: &self } } - pub fn http_health_checks(&'a self) -> HttpHealthCheckMethods<'a, C, NC, A> { + pub fn http_health_checks(&'a self) -> HttpHealthCheckMethods<'a, C, A> { HttpHealthCheckMethods { hub: &self } } - pub fn images(&'a self) -> ImageMethods<'a, C, NC, A> { + pub fn images(&'a self) -> ImageMethods<'a, C, A> { ImageMethods { hub: &self } } - pub fn instance_templates(&'a self) -> InstanceTemplateMethods<'a, C, NC, A> { + pub fn instance_templates(&'a self) -> InstanceTemplateMethods<'a, C, A> { InstanceTemplateMethods { hub: &self } } - pub fn instances(&'a self) -> InstanceMethods<'a, C, NC, A> { + pub fn instances(&'a self) -> InstanceMethods<'a, C, A> { InstanceMethods { hub: &self } } - pub fn licenses(&'a self) -> LicenseMethods<'a, C, NC, A> { + pub fn licenses(&'a self) -> LicenseMethods<'a, C, A> { LicenseMethods { hub: &self } } - pub fn machine_types(&'a self) -> MachineTypeMethods<'a, C, NC, A> { + pub fn machine_types(&'a self) -> MachineTypeMethods<'a, C, A> { MachineTypeMethods { hub: &self } } - pub fn networks(&'a self) -> NetworkMethods<'a, C, NC, A> { + pub fn networks(&'a self) -> NetworkMethods<'a, C, A> { NetworkMethods { hub: &self } } - pub fn projects(&'a self) -> ProjectMethods<'a, C, NC, A> { + pub fn projects(&'a self) -> ProjectMethods<'a, C, A> { ProjectMethods { hub: &self } } - pub fn region_operations(&'a self) -> RegionOperationMethods<'a, C, NC, A> { + pub fn region_operations(&'a self) -> RegionOperationMethods<'a, C, A> { RegionOperationMethods { hub: &self } } - pub fn regions(&'a self) -> RegionMethods<'a, C, NC, A> { + pub fn regions(&'a self) -> RegionMethods<'a, C, A> { RegionMethods { hub: &self } } - pub fn routes(&'a self) -> RouteMethods<'a, C, NC, A> { + pub fn routes(&'a self) -> RouteMethods<'a, C, A> { RouteMethods { hub: &self } } - pub fn snapshots(&'a self) -> SnapshotMethods<'a, C, NC, A> { + pub fn snapshots(&'a self) -> SnapshotMethods<'a, C, A> { SnapshotMethods { hub: &self } } - pub fn target_http_proxies(&'a self) -> TargetHttpProxyMethods<'a, C, NC, A> { + pub fn target_http_proxies(&'a self) -> TargetHttpProxyMethods<'a, C, A> { TargetHttpProxyMethods { hub: &self } } - pub fn target_instances(&'a self) -> TargetInstanceMethods<'a, C, NC, A> { + pub fn target_instances(&'a self) -> TargetInstanceMethods<'a, C, A> { TargetInstanceMethods { hub: &self } } - pub fn target_pools(&'a self) -> TargetPoolMethods<'a, C, NC, A> { + pub fn target_pools(&'a self) -> TargetPoolMethods<'a, C, A> { TargetPoolMethods { hub: &self } } - pub fn target_vpn_gateways(&'a self) -> TargetVpnGatewayMethods<'a, C, NC, A> { + pub fn target_vpn_gateways(&'a self) -> TargetVpnGatewayMethods<'a, C, A> { TargetVpnGatewayMethods { hub: &self } } - pub fn url_maps(&'a self) -> UrlMapMethods<'a, C, NC, A> { + pub fn url_maps(&'a self) -> UrlMapMethods<'a, C, A> { UrlMapMethods { hub: &self } } - pub fn vpn_tunnels(&'a self) -> VpnTunnelMethods<'a, C, NC, A> { + pub fn vpn_tunnels(&'a self) -> VpnTunnelMethods<'a, C, A> { VpnTunnelMethods { hub: &self } } - pub fn zone_operations(&'a self) -> ZoneOperationMethods<'a, C, NC, A> { + pub fn zone_operations(&'a self) -> ZoneOperationMethods<'a, C, A> { ZoneOperationMethods { hub: &self } } - pub fn zones(&'a self) -> ZoneMethods<'a, C, NC, A> { + pub fn zones(&'a self) -> ZoneMethods<'a, C, A> { ZoneMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -4465,15 +4461,15 @@ impl Part for Backend {} /// let rb = hub.disks(); /// # } /// ``` -pub struct DiskMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DiskMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for DiskMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for DiskMethods<'a, C, A> {} -impl<'a, C, NC, A> DiskMethods<'a, C, NC, A> { +impl<'a, C, A> DiskMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -4484,7 +4480,7 @@ impl<'a, C, NC, A> DiskMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `zone` - The name of the zone for this request. /// * `disk` - Name of the persistent disk to delete. - pub fn delete(&self, project: &str, zone: &str, disk: &str) -> DiskDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, zone: &str, disk: &str) -> DiskDeleteCall<'a, C, A> { DiskDeleteCall { hub: self.hub, _project: project.to_string(), @@ -4503,7 +4499,7 @@ impl<'a, C, NC, A> DiskMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Project ID for this request. - pub fn aggregated_list(&self, project: &str) -> DiskAggregatedListCall<'a, C, NC, A> { + pub fn aggregated_list(&self, project: &str) -> DiskAggregatedListCall<'a, C, A> { DiskAggregatedListCall { hub: self.hub, _project: project.to_string(), @@ -4524,7 +4520,7 @@ impl<'a, C, NC, A> DiskMethods<'a, C, NC, A> { /// /// * `project` - Project ID for this request. /// * `zone` - The name of the zone for this request. - pub fn list(&self, project: &str, zone: &str) -> DiskListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, zone: &str) -> DiskListCall<'a, C, A> { DiskListCall { hub: self.hub, _project: project.to_string(), @@ -4547,7 +4543,7 @@ impl<'a, C, NC, A> DiskMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Project ID for this request. /// * `zone` - The name of the zone for this request. - pub fn insert(&self, request: &Disk, project: &str, zone: &str) -> DiskInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Disk, project: &str, zone: &str) -> DiskInsertCall<'a, C, A> { DiskInsertCall { hub: self.hub, _request: request.clone(), @@ -4570,7 +4566,7 @@ impl<'a, C, NC, A> DiskMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `zone` - The name of the zone for this request. /// * `disk` - Name of the persistent disk to snapshot. - pub fn create_snapshot(&self, request: &Snapshot, project: &str, zone: &str, disk: &str) -> DiskCreateSnapshotCall<'a, C, NC, A> { + pub fn create_snapshot(&self, request: &Snapshot, project: &str, zone: &str, disk: &str) -> DiskCreateSnapshotCall<'a, C, A> { DiskCreateSnapshotCall { hub: self.hub, _request: request.clone(), @@ -4592,7 +4588,7 @@ impl<'a, C, NC, A> DiskMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `zone` - The name of the zone for this request. /// * `disk` - Name of the persistent disk to return. - pub fn get(&self, project: &str, zone: &str, disk: &str) -> DiskGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, zone: &str, disk: &str) -> DiskGetCall<'a, C, A> { DiskGetCall { hub: self.hub, _project: project.to_string(), @@ -4635,15 +4631,15 @@ impl<'a, C, NC, A> DiskMethods<'a, C, NC, A> { /// let rb = hub.addresses(); /// # } /// ``` -pub struct AddresseMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AddresseMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for AddresseMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AddresseMethods<'a, C, A> {} -impl<'a, C, NC, A> AddresseMethods<'a, C, NC, A> { +impl<'a, C, A> AddresseMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -4653,7 +4649,7 @@ impl<'a, C, NC, A> AddresseMethods<'a, C, NC, A> { /// /// * `project` - Project ID for this request. /// * `region` - The name of the region for this request. - pub fn list(&self, project: &str, region: &str) -> AddresseListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, region: &str) -> AddresseListCall<'a, C, A> { AddresseListCall { hub: self.hub, _project: project.to_string(), @@ -4674,7 +4670,7 @@ impl<'a, C, NC, A> AddresseMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Project ID for this request. - pub fn aggregated_list(&self, project: &str) -> AddresseAggregatedListCall<'a, C, NC, A> { + pub fn aggregated_list(&self, project: &str) -> AddresseAggregatedListCall<'a, C, A> { AddresseAggregatedListCall { hub: self.hub, _project: project.to_string(), @@ -4696,7 +4692,7 @@ impl<'a, C, NC, A> AddresseMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `region` - The name of the region for this request. /// * `address` - Name of the address resource to return. - pub fn get(&self, project: &str, region: &str, address: &str) -> AddresseGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, region: &str, address: &str) -> AddresseGetCall<'a, C, A> { AddresseGetCall { hub: self.hub, _project: project.to_string(), @@ -4717,7 +4713,7 @@ impl<'a, C, NC, A> AddresseMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Project ID for this request. /// * `region` - The name of the region for this request. - pub fn insert(&self, request: &Address, project: &str, region: &str) -> AddresseInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Address, project: &str, region: &str) -> AddresseInsertCall<'a, C, A> { AddresseInsertCall { hub: self.hub, _request: request.clone(), @@ -4738,7 +4734,7 @@ impl<'a, C, NC, A> AddresseMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `region` - The name of the region for this request. /// * `address` - Name of the address resource to delete. - pub fn delete(&self, project: &str, region: &str, address: &str) -> AddresseDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, region: &str, address: &str) -> AddresseDeleteCall<'a, C, A> { AddresseDeleteCall { hub: self.hub, _project: project.to_string(), @@ -4781,15 +4777,15 @@ impl<'a, C, NC, A> AddresseMethods<'a, C, NC, A> { /// let rb = hub.url_maps(); /// # } /// ``` -pub struct UrlMapMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlMapMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for UrlMapMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for UrlMapMethods<'a, C, A> {} -impl<'a, C, NC, A> UrlMapMethods<'a, C, NC, A> { +impl<'a, C, A> UrlMapMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -4799,7 +4795,7 @@ impl<'a, C, NC, A> UrlMapMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `project` - Name of the project scoping this request. - pub fn insert(&self, request: &UrlMap, project: &str) -> UrlMapInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &UrlMap, project: &str) -> UrlMapInsertCall<'a, C, A> { UrlMapInsertCall { hub: self.hub, _request: request.clone(), @@ -4818,7 +4814,7 @@ impl<'a, C, NC, A> UrlMapMethods<'a, C, NC, A> { /// /// * `project` - Name of the project scoping this request. /// * `urlMap` - Name of the UrlMap resource to return. - pub fn get(&self, project: &str, url_map: &str) -> UrlMapGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, url_map: &str) -> UrlMapGetCall<'a, C, A> { UrlMapGetCall { hub: self.hub, _project: project.to_string(), @@ -4838,7 +4834,7 @@ impl<'a, C, NC, A> UrlMapMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Name of the project scoping this request. /// * `urlMap` - Name of the UrlMap resource to be validated as. - pub fn validate(&self, request: &UrlMapsValidateRequest, project: &str, url_map: &str) -> UrlMapValidateCall<'a, C, NC, A> { + pub fn validate(&self, request: &UrlMapsValidateRequest, project: &str, url_map: &str) -> UrlMapValidateCall<'a, C, A> { UrlMapValidateCall { hub: self.hub, _request: request.clone(), @@ -4857,7 +4853,7 @@ impl<'a, C, NC, A> UrlMapMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Name of the project scoping this request. - pub fn list(&self, project: &str) -> UrlMapListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> UrlMapListCall<'a, C, A> { UrlMapListCall { hub: self.hub, _project: project.to_string(), @@ -4879,7 +4875,7 @@ impl<'a, C, NC, A> UrlMapMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Name of the project scoping this request. /// * `urlMap` - Name of the UrlMap resource to update. - pub fn patch(&self, request: &UrlMap, project: &str, url_map: &str) -> UrlMapPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &UrlMap, project: &str, url_map: &str) -> UrlMapPatchCall<'a, C, A> { UrlMapPatchCall { hub: self.hub, _request: request.clone(), @@ -4900,7 +4896,7 @@ impl<'a, C, NC, A> UrlMapMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Name of the project scoping this request. /// * `urlMap` - Name of the UrlMap resource to update. - pub fn update(&self, request: &UrlMap, project: &str, url_map: &str) -> UrlMapUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &UrlMap, project: &str, url_map: &str) -> UrlMapUpdateCall<'a, C, A> { UrlMapUpdateCall { hub: self.hub, _request: request.clone(), @@ -4920,7 +4916,7 @@ impl<'a, C, NC, A> UrlMapMethods<'a, C, NC, A> { /// /// * `project` - Name of the project scoping this request. /// * `urlMap` - Name of the UrlMap resource to delete. - pub fn delete(&self, project: &str, url_map: &str) -> UrlMapDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, url_map: &str) -> UrlMapDeleteCall<'a, C, A> { UrlMapDeleteCall { hub: self.hub, _project: project.to_string(), @@ -4962,15 +4958,15 @@ impl<'a, C, NC, A> UrlMapMethods<'a, C, NC, A> { /// let rb = hub.global_addresses(); /// # } /// ``` -pub struct GlobalAddresseMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GlobalAddresseMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for GlobalAddresseMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for GlobalAddresseMethods<'a, C, A> {} -impl<'a, C, NC, A> GlobalAddresseMethods<'a, C, NC, A> { +impl<'a, C, A> GlobalAddresseMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -4980,7 +4976,7 @@ impl<'a, C, NC, A> GlobalAddresseMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `project` - Project ID for this request. - pub fn insert(&self, request: &Address, project: &str) -> GlobalAddresseInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Address, project: &str) -> GlobalAddresseInsertCall<'a, C, A> { GlobalAddresseInsertCall { hub: self.hub, _request: request.clone(), @@ -4998,7 +4994,7 @@ impl<'a, C, NC, A> GlobalAddresseMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Project ID for this request. - pub fn list(&self, project: &str) -> GlobalAddresseListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> GlobalAddresseListCall<'a, C, A> { GlobalAddresseListCall { hub: self.hub, _project: project.to_string(), @@ -5019,7 +5015,7 @@ impl<'a, C, NC, A> GlobalAddresseMethods<'a, C, NC, A> { /// /// * `project` - Project ID for this request. /// * `address` - Name of the address resource to return. - pub fn get(&self, project: &str, address: &str) -> GlobalAddresseGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, address: &str) -> GlobalAddresseGetCall<'a, C, A> { GlobalAddresseGetCall { hub: self.hub, _project: project.to_string(), @@ -5038,7 +5034,7 @@ impl<'a, C, NC, A> GlobalAddresseMethods<'a, C, NC, A> { /// /// * `project` - Project ID for this request. /// * `address` - Name of the address resource to delete. - pub fn delete(&self, project: &str, address: &str) -> GlobalAddresseDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, address: &str) -> GlobalAddresseDeleteCall<'a, C, A> { GlobalAddresseDeleteCall { hub: self.hub, _project: project.to_string(), @@ -5080,15 +5076,15 @@ impl<'a, C, NC, A> GlobalAddresseMethods<'a, C, NC, A> { /// let rb = hub.snapshots(); /// # } /// ``` -pub struct SnapshotMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SnapshotMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for SnapshotMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for SnapshotMethods<'a, C, A> {} -impl<'a, C, NC, A> SnapshotMethods<'a, C, NC, A> { +impl<'a, C, A> SnapshotMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -5098,7 +5094,7 @@ impl<'a, C, NC, A> SnapshotMethods<'a, C, NC, A> { /// /// * `project` - Name of the project scoping this request. /// * `snapshot` - Name of the persistent disk snapshot resource to return. - pub fn get(&self, project: &str, snapshot: &str) -> SnapshotGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, snapshot: &str) -> SnapshotGetCall<'a, C, A> { SnapshotGetCall { hub: self.hub, _project: project.to_string(), @@ -5116,7 +5112,7 @@ impl<'a, C, NC, A> SnapshotMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Name of the project scoping this request. - pub fn list(&self, project: &str) -> SnapshotListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> SnapshotListCall<'a, C, A> { SnapshotListCall { hub: self.hub, _project: project.to_string(), @@ -5137,7 +5133,7 @@ impl<'a, C, NC, A> SnapshotMethods<'a, C, NC, A> { /// /// * `project` - Name of the project scoping this request. /// * `snapshot` - Name of the persistent disk snapshot resource to delete. - pub fn delete(&self, project: &str, snapshot: &str) -> SnapshotDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, snapshot: &str) -> SnapshotDeleteCall<'a, C, A> { SnapshotDeleteCall { hub: self.hub, _project: project.to_string(), @@ -5179,15 +5175,15 @@ impl<'a, C, NC, A> SnapshotMethods<'a, C, NC, A> { /// let rb = hub.disk_types(); /// # } /// ``` -pub struct DiskTypeMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DiskTypeMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for DiskTypeMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for DiskTypeMethods<'a, C, A> {} -impl<'a, C, NC, A> DiskTypeMethods<'a, C, NC, A> { +impl<'a, C, A> DiskTypeMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -5198,7 +5194,7 @@ impl<'a, C, NC, A> DiskTypeMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `zone` - The name of the zone for this request. /// * `diskType` - Name of the disk type resource to return. - pub fn get(&self, project: &str, zone: &str, disk_type: &str) -> DiskTypeGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, zone: &str, disk_type: &str) -> DiskTypeGetCall<'a, C, A> { DiskTypeGetCall { hub: self.hub, _project: project.to_string(), @@ -5217,7 +5213,7 @@ impl<'a, C, NC, A> DiskTypeMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Project ID for this request. - pub fn aggregated_list(&self, project: &str) -> DiskTypeAggregatedListCall<'a, C, NC, A> { + pub fn aggregated_list(&self, project: &str) -> DiskTypeAggregatedListCall<'a, C, A> { DiskTypeAggregatedListCall { hub: self.hub, _project: project.to_string(), @@ -5238,7 +5234,7 @@ impl<'a, C, NC, A> DiskTypeMethods<'a, C, NC, A> { /// /// * `project` - Project ID for this request. /// * `zone` - The name of the zone for this request. - pub fn list(&self, project: &str, zone: &str) -> DiskTypeListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, zone: &str) -> DiskTypeListCall<'a, C, A> { DiskTypeListCall { hub: self.hub, _project: project.to_string(), @@ -5283,15 +5279,15 @@ impl<'a, C, NC, A> DiskTypeMethods<'a, C, NC, A> { /// let rb = hub.zones(); /// # } /// ``` -pub struct ZoneMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for ZoneMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ZoneMethods<'a, C, A> {} -impl<'a, C, NC, A> ZoneMethods<'a, C, NC, A> { +impl<'a, C, A> ZoneMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -5301,7 +5297,7 @@ impl<'a, C, NC, A> ZoneMethods<'a, C, NC, A> { /// /// * `project` - Project ID for this request. /// * `zone` - Name of the zone resource to return. - pub fn get(&self, project: &str, zone: &str) -> ZoneGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, zone: &str) -> ZoneGetCall<'a, C, A> { ZoneGetCall { hub: self.hub, _project: project.to_string(), @@ -5319,7 +5315,7 @@ impl<'a, C, NC, A> ZoneMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Project ID for this request. - pub fn list(&self, project: &str) -> ZoneListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> ZoneListCall<'a, C, A> { ZoneListCall { hub: self.hub, _project: project.to_string(), @@ -5363,15 +5359,15 @@ impl<'a, C, NC, A> ZoneMethods<'a, C, NC, A> { /// let rb = hub.instances(); /// # } /// ``` -pub struct InstanceMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for InstanceMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for InstanceMethods<'a, C, A> {} -impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { +impl<'a, C, A> InstanceMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -5383,7 +5379,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `zone` - The name of the zone for this request. /// * `instance` - Instance name. - pub fn set_scheduling(&self, request: &Scheduling, project: &str, zone: &str, instance: &str) -> InstanceSetSchedulingCall<'a, C, NC, A> { + pub fn set_scheduling(&self, request: &Scheduling, project: &str, zone: &str, instance: &str) -> InstanceSetSchedulingCall<'a, C, A> { InstanceSetSchedulingCall { hub: self.hub, _request: request.clone(), @@ -5405,7 +5401,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `zone` - The name of the zone for this request. /// * `instance` - Name of the instance resource to delete. - pub fn delete(&self, project: &str, zone: &str, instance: &str) -> InstanceDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, zone: &str, instance: &str) -> InstanceDeleteCall<'a, C, A> { InstanceDeleteCall { hub: self.hub, _project: project.to_string(), @@ -5426,7 +5422,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `zone` - The name of the zone for this request. /// * `instance` - Name of the instance scoping this request. - pub fn get_serial_port_output(&self, project: &str, zone: &str, instance: &str) -> InstanceGetSerialPortOutputCall<'a, C, NC, A> { + pub fn get_serial_port_output(&self, project: &str, zone: &str, instance: &str) -> InstanceGetSerialPortOutputCall<'a, C, A> { InstanceGetSerialPortOutputCall { hub: self.hub, _project: project.to_string(), @@ -5449,7 +5445,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// * `instance` - The instance name. /// * `autoDelete` - Whether to auto-delete the disk when the instance is deleted. /// * `deviceName` - The device name of the disk to modify. - pub fn set_disk_auto_delete(&self, project: &str, zone: &str, instance: &str, auto_delete: bool, device_name: &str) -> InstanceSetDiskAutoDeleteCall<'a, C, NC, A> { + pub fn set_disk_auto_delete(&self, project: &str, zone: &str, instance: &str, auto_delete: bool, device_name: &str) -> InstanceSetDiskAutoDeleteCall<'a, C, A> { InstanceSetDiskAutoDeleteCall { hub: self.hub, _project: project.to_string(), @@ -5474,7 +5470,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// * `zone` - The name of the zone for this request. /// * `instance` - The instance name for this request. /// * `networkInterface` - The name of the network interface to add to this instance. - pub fn add_access_config(&self, request: &AccessConfig, project: &str, zone: &str, instance: &str, network_interface: &str) -> InstanceAddAccessConfigCall<'a, C, NC, A> { + pub fn add_access_config(&self, request: &AccessConfig, project: &str, zone: &str, instance: &str, network_interface: &str) -> InstanceAddAccessConfigCall<'a, C, A> { InstanceAddAccessConfigCall { hub: self.hub, _request: request.clone(), @@ -5497,7 +5493,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `zone` - The name of the zone for this request. /// * `instance` - Name of the instance resource to start. - pub fn start(&self, project: &str, zone: &str, instance: &str) -> InstanceStartCall<'a, C, NC, A> { + pub fn start(&self, project: &str, zone: &str, instance: &str) -> InstanceStartCall<'a, C, A> { InstanceStartCall { hub: self.hub, _project: project.to_string(), @@ -5518,7 +5514,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `zone` - The name of the The name of the zone for this request.. /// * `instance` - Name of the instance resource to return. - pub fn get(&self, project: &str, zone: &str, instance: &str) -> InstanceGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, zone: &str, instance: &str) -> InstanceGetCall<'a, C, A> { InstanceGetCall { hub: self.hub, _project: project.to_string(), @@ -5540,7 +5536,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `zone` - The name of the zone for this request. /// * `instance` - Name of the instance scoping this request. - pub fn set_tags(&self, request: &Tags, project: &str, zone: &str, instance: &str) -> InstanceSetTagCall<'a, C, NC, A> { + pub fn set_tags(&self, request: &Tags, project: &str, zone: &str, instance: &str) -> InstanceSetTagCall<'a, C, A> { InstanceSetTagCall { hub: self.hub, _request: request.clone(), @@ -5563,7 +5559,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `zone` - The name of the zone for this request. /// * `instance` - Name of the instance scoping this request. - pub fn set_metadata(&self, request: &Metadata, project: &str, zone: &str, instance: &str) -> InstanceSetMetadataCall<'a, C, NC, A> { + pub fn set_metadata(&self, request: &Metadata, project: &str, zone: &str, instance: &str) -> InstanceSetMetadataCall<'a, C, A> { InstanceSetMetadataCall { hub: self.hub, _request: request.clone(), @@ -5586,7 +5582,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// * `zone` - The name of the zone for this request. /// * `instance` - Instance name. /// * `deviceName` - Disk device name to detach. - pub fn detach_disk(&self, project: &str, zone: &str, instance: &str, device_name: &str) -> InstanceDetachDiskCall<'a, C, NC, A> { + pub fn detach_disk(&self, project: &str, zone: &str, instance: &str, device_name: &str) -> InstanceDetachDiskCall<'a, C, A> { InstanceDetachDiskCall { hub: self.hub, _project: project.to_string(), @@ -5608,7 +5604,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `zone` - The name of the zone for this request. /// * `instance` - Name of the instance resource to start. - pub fn stop(&self, project: &str, zone: &str, instance: &str) -> InstanceStopCall<'a, C, NC, A> { + pub fn stop(&self, project: &str, zone: &str, instance: &str) -> InstanceStopCall<'a, C, A> { InstanceStopCall { hub: self.hub, _project: project.to_string(), @@ -5629,7 +5625,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Project ID for this request. /// * `zone` - The name of the zone for this request. - pub fn insert(&self, request: &Instance, project: &str, zone: &str) -> InstanceInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Instance, project: &str, zone: &str) -> InstanceInsertCall<'a, C, A> { InstanceInsertCall { hub: self.hub, _request: request.clone(), @@ -5650,7 +5646,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `zone` - The name of the zone for this request. /// * `instance` - Name of the instance scoping this request. - pub fn reset(&self, project: &str, zone: &str, instance: &str) -> InstanceResetCall<'a, C, NC, A> { + pub fn reset(&self, project: &str, zone: &str, instance: &str) -> InstanceResetCall<'a, C, A> { InstanceResetCall { hub: self.hub, _project: project.to_string(), @@ -5673,7 +5669,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// * `instance` - The instance name for this request. /// * `accessConfig` - The name of the access config to delete. /// * `networkInterface` - The name of the network interface. - pub fn delete_access_config(&self, project: &str, zone: &str, instance: &str, access_config: &str, network_interface: &str) -> InstanceDeleteAccessConfigCall<'a, C, NC, A> { + pub fn delete_access_config(&self, project: &str, zone: &str, instance: &str, access_config: &str, network_interface: &str) -> InstanceDeleteAccessConfigCall<'a, C, A> { InstanceDeleteAccessConfigCall { hub: self.hub, _project: project.to_string(), @@ -5697,7 +5693,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `zone` - The name of the zone for this request. /// * `instance` - Instance name. - pub fn attach_disk(&self, request: &AttachedDisk, project: &str, zone: &str, instance: &str) -> InstanceAttachDiskCall<'a, C, NC, A> { + pub fn attach_disk(&self, request: &AttachedDisk, project: &str, zone: &str, instance: &str) -> InstanceAttachDiskCall<'a, C, A> { InstanceAttachDiskCall { hub: self.hub, _request: request.clone(), @@ -5718,7 +5714,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// /// * `project` - Project ID for this request. /// * `zone` - The name of the zone for this request. - pub fn list(&self, project: &str, zone: &str) -> InstanceListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, zone: &str) -> InstanceListCall<'a, C, A> { InstanceListCall { hub: self.hub, _project: project.to_string(), @@ -5736,7 +5732,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Project ID for this request. - pub fn aggregated_list(&self, project: &str) -> InstanceAggregatedListCall<'a, C, NC, A> { + pub fn aggregated_list(&self, project: &str) -> InstanceAggregatedListCall<'a, C, A> { InstanceAggregatedListCall { hub: self.hub, _project: project.to_string(), @@ -5780,15 +5776,15 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// let rb = hub.backend_services(); /// # } /// ``` -pub struct BackendServiceMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BackendServiceMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for BackendServiceMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for BackendServiceMethods<'a, C, A> {} -impl<'a, C, NC, A> BackendServiceMethods<'a, C, NC, A> { +impl<'a, C, A> BackendServiceMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -5799,7 +5795,7 @@ impl<'a, C, NC, A> BackendServiceMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - No description provided. /// * `backendService` - Name of the BackendService resource to which the queried instance belongs. - pub fn get_health(&self, request: &ResourceGroupReference, project: &str, backend_service: &str) -> BackendServiceGetHealthCall<'a, C, NC, A> { + pub fn get_health(&self, request: &ResourceGroupReference, project: &str, backend_service: &str) -> BackendServiceGetHealthCall<'a, C, A> { BackendServiceGetHealthCall { hub: self.hub, _request: request.clone(), @@ -5819,7 +5815,7 @@ impl<'a, C, NC, A> BackendServiceMethods<'a, C, NC, A> { /// /// * `project` - Name of the project scoping this request. /// * `backendService` - Name of the BackendService resource to delete. - pub fn delete(&self, project: &str, backend_service: &str) -> BackendServiceDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, backend_service: &str) -> BackendServiceDeleteCall<'a, C, A> { BackendServiceDeleteCall { hub: self.hub, _project: project.to_string(), @@ -5838,7 +5834,7 @@ impl<'a, C, NC, A> BackendServiceMethods<'a, C, NC, A> { /// /// * `project` - Name of the project scoping this request. /// * `backendService` - Name of the BackendService resource to return. - pub fn get(&self, project: &str, backend_service: &str) -> BackendServiceGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, backend_service: &str) -> BackendServiceGetCall<'a, C, A> { BackendServiceGetCall { hub: self.hub, _project: project.to_string(), @@ -5858,7 +5854,7 @@ impl<'a, C, NC, A> BackendServiceMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Name of the project scoping this request. /// * `backendService` - Name of the BackendService resource to update. - pub fn update(&self, request: &BackendService, project: &str, backend_service: &str) -> BackendServiceUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &BackendService, project: &str, backend_service: &str) -> BackendServiceUpdateCall<'a, C, A> { BackendServiceUpdateCall { hub: self.hub, _request: request.clone(), @@ -5877,7 +5873,7 @@ impl<'a, C, NC, A> BackendServiceMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Name of the project scoping this request. - pub fn list(&self, project: &str) -> BackendServiceListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> BackendServiceListCall<'a, C, A> { BackendServiceListCall { hub: self.hub, _project: project.to_string(), @@ -5899,7 +5895,7 @@ impl<'a, C, NC, A> BackendServiceMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Name of the project scoping this request. /// * `backendService` - Name of the BackendService resource to update. - pub fn patch(&self, request: &BackendService, project: &str, backend_service: &str) -> BackendServicePatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &BackendService, project: &str, backend_service: &str) -> BackendServicePatchCall<'a, C, A> { BackendServicePatchCall { hub: self.hub, _request: request.clone(), @@ -5919,7 +5915,7 @@ impl<'a, C, NC, A> BackendServiceMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `project` - Name of the project scoping this request. - pub fn insert(&self, request: &BackendService, project: &str) -> BackendServiceInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &BackendService, project: &str) -> BackendServiceInsertCall<'a, C, A> { BackendServiceInsertCall { hub: self.hub, _request: request.clone(), @@ -5961,15 +5957,15 @@ impl<'a, C, NC, A> BackendServiceMethods<'a, C, NC, A> { /// let rb = hub.licenses(); /// # } /// ``` -pub struct LicenseMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LicenseMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for LicenseMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for LicenseMethods<'a, C, A> {} -impl<'a, C, NC, A> LicenseMethods<'a, C, NC, A> { +impl<'a, C, A> LicenseMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -5979,7 +5975,7 @@ impl<'a, C, NC, A> LicenseMethods<'a, C, NC, A> { /// /// * `project` - Project ID for this request. /// * `license` - Name of the license resource to return. - pub fn get(&self, project: &str, license: &str) -> LicenseGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, license: &str) -> LicenseGetCall<'a, C, A> { LicenseGetCall { hub: self.hub, _project: project.to_string(), @@ -6021,15 +6017,15 @@ impl<'a, C, NC, A> LicenseMethods<'a, C, NC, A> { /// let rb = hub.networks(); /// # } /// ``` -pub struct NetworkMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct NetworkMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for NetworkMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for NetworkMethods<'a, C, A> {} -impl<'a, C, NC, A> NetworkMethods<'a, C, NC, A> { +impl<'a, C, A> NetworkMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -6039,7 +6035,7 @@ impl<'a, C, NC, A> NetworkMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `project` - Project ID for this request. - pub fn insert(&self, request: &Network, project: &str) -> NetworkInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Network, project: &str) -> NetworkInsertCall<'a, C, A> { NetworkInsertCall { hub: self.hub, _request: request.clone(), @@ -6057,7 +6053,7 @@ impl<'a, C, NC, A> NetworkMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Project ID for this request. - pub fn list(&self, project: &str) -> NetworkListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> NetworkListCall<'a, C, A> { NetworkListCall { hub: self.hub, _project: project.to_string(), @@ -6078,7 +6074,7 @@ impl<'a, C, NC, A> NetworkMethods<'a, C, NC, A> { /// /// * `project` - Project ID for this request. /// * `network` - Name of the network resource to delete. - pub fn delete(&self, project: &str, network: &str) -> NetworkDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, network: &str) -> NetworkDeleteCall<'a, C, A> { NetworkDeleteCall { hub: self.hub, _project: project.to_string(), @@ -6097,7 +6093,7 @@ impl<'a, C, NC, A> NetworkMethods<'a, C, NC, A> { /// /// * `project` - Project ID for this request. /// * `network` - Name of the network resource to return. - pub fn get(&self, project: &str, network: &str) -> NetworkGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, network: &str) -> NetworkGetCall<'a, C, A> { NetworkGetCall { hub: self.hub, _project: project.to_string(), @@ -6139,15 +6135,15 @@ impl<'a, C, NC, A> NetworkMethods<'a, C, NC, A> { /// let rb = hub.global_operations(); /// # } /// ``` -pub struct GlobalOperationMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GlobalOperationMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for GlobalOperationMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for GlobalOperationMethods<'a, C, A> {} -impl<'a, C, NC, A> GlobalOperationMethods<'a, C, NC, A> { +impl<'a, C, A> GlobalOperationMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -6156,7 +6152,7 @@ impl<'a, C, NC, A> GlobalOperationMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Project ID for this request. - pub fn list(&self, project: &str) -> GlobalOperationListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> GlobalOperationListCall<'a, C, A> { GlobalOperationListCall { hub: self.hub, _project: project.to_string(), @@ -6177,7 +6173,7 @@ impl<'a, C, NC, A> GlobalOperationMethods<'a, C, NC, A> { /// /// * `project` - Project ID for this request. /// * `operation` - Name of the operation resource to return. - pub fn get(&self, project: &str, operation: &str) -> GlobalOperationGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, operation: &str) -> GlobalOperationGetCall<'a, C, A> { GlobalOperationGetCall { hub: self.hub, _project: project.to_string(), @@ -6196,7 +6192,7 @@ impl<'a, C, NC, A> GlobalOperationMethods<'a, C, NC, A> { /// /// * `project` - Project ID for this request. /// * `operation` - Name of the operation resource to delete. - pub fn delete(&self, project: &str, operation: &str) -> GlobalOperationDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, operation: &str) -> GlobalOperationDeleteCall<'a, C, A> { GlobalOperationDeleteCall { hub: self.hub, _project: project.to_string(), @@ -6214,7 +6210,7 @@ impl<'a, C, NC, A> GlobalOperationMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Project ID for this request. - pub fn aggregated_list(&self, project: &str) -> GlobalOperationAggregatedListCall<'a, C, NC, A> { + pub fn aggregated_list(&self, project: &str) -> GlobalOperationAggregatedListCall<'a, C, A> { GlobalOperationAggregatedListCall { hub: self.hub, _project: project.to_string(), @@ -6258,15 +6254,15 @@ impl<'a, C, NC, A> GlobalOperationMethods<'a, C, NC, A> { /// let rb = hub.regions(); /// # } /// ``` -pub struct RegionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RegionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for RegionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for RegionMethods<'a, C, A> {} -impl<'a, C, NC, A> RegionMethods<'a, C, NC, A> { +impl<'a, C, A> RegionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -6275,7 +6271,7 @@ impl<'a, C, NC, A> RegionMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Project ID for this request. - pub fn list(&self, project: &str) -> RegionListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> RegionListCall<'a, C, A> { RegionListCall { hub: self.hub, _project: project.to_string(), @@ -6296,7 +6292,7 @@ impl<'a, C, NC, A> RegionMethods<'a, C, NC, A> { /// /// * `project` - Project ID for this request. /// * `region` - Name of the region resource to return. - pub fn get(&self, project: &str, region: &str) -> RegionGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, region: &str) -> RegionGetCall<'a, C, A> { RegionGetCall { hub: self.hub, _project: project.to_string(), @@ -6338,15 +6334,15 @@ impl<'a, C, NC, A> RegionMethods<'a, C, NC, A> { /// let rb = hub.forwarding_rules(); /// # } /// ``` -pub struct ForwardingRuleMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ForwardingRuleMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for ForwardingRuleMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ForwardingRuleMethods<'a, C, A> {} -impl<'a, C, NC, A> ForwardingRuleMethods<'a, C, NC, A> { +impl<'a, C, A> ForwardingRuleMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -6355,7 +6351,7 @@ impl<'a, C, NC, A> ForwardingRuleMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Name of the project scoping this request. - pub fn aggregated_list(&self, project: &str) -> ForwardingRuleAggregatedListCall<'a, C, NC, A> { + pub fn aggregated_list(&self, project: &str) -> ForwardingRuleAggregatedListCall<'a, C, A> { ForwardingRuleAggregatedListCall { hub: self.hub, _project: project.to_string(), @@ -6377,7 +6373,7 @@ impl<'a, C, NC, A> ForwardingRuleMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Name of the project scoping this request. /// * `region` - Name of the region scoping this request. - pub fn insert(&self, request: &ForwardingRule, project: &str, region: &str) -> ForwardingRuleInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &ForwardingRule, project: &str, region: &str) -> ForwardingRuleInsertCall<'a, C, A> { ForwardingRuleInsertCall { hub: self.hub, _request: request.clone(), @@ -6399,7 +6395,7 @@ impl<'a, C, NC, A> ForwardingRuleMethods<'a, C, NC, A> { /// * `project` - Name of the project scoping this request. /// * `region` - Name of the region scoping this request. /// * `forwardingRule` - Name of the ForwardingRule resource in which target is to be set. - pub fn set_target(&self, request: &TargetReference, project: &str, region: &str, forwarding_rule: &str) -> ForwardingRuleSetTargetCall<'a, C, NC, A> { + pub fn set_target(&self, request: &TargetReference, project: &str, region: &str, forwarding_rule: &str) -> ForwardingRuleSetTargetCall<'a, C, A> { ForwardingRuleSetTargetCall { hub: self.hub, _request: request.clone(), @@ -6421,7 +6417,7 @@ impl<'a, C, NC, A> ForwardingRuleMethods<'a, C, NC, A> { /// * `project` - Name of the project scoping this request. /// * `region` - Name of the region scoping this request. /// * `forwardingRule` - Name of the ForwardingRule resource to return. - pub fn get(&self, project: &str, region: &str, forwarding_rule: &str) -> ForwardingRuleGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, region: &str, forwarding_rule: &str) -> ForwardingRuleGetCall<'a, C, A> { ForwardingRuleGetCall { hub: self.hub, _project: project.to_string(), @@ -6441,7 +6437,7 @@ impl<'a, C, NC, A> ForwardingRuleMethods<'a, C, NC, A> { /// /// * `project` - Name of the project scoping this request. /// * `region` - Name of the region scoping this request. - pub fn list(&self, project: &str, region: &str) -> ForwardingRuleListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, region: &str) -> ForwardingRuleListCall<'a, C, A> { ForwardingRuleListCall { hub: self.hub, _project: project.to_string(), @@ -6464,7 +6460,7 @@ impl<'a, C, NC, A> ForwardingRuleMethods<'a, C, NC, A> { /// * `project` - Name of the project scoping this request. /// * `region` - Name of the region scoping this request. /// * `forwardingRule` - Name of the ForwardingRule resource to delete. - pub fn delete(&self, project: &str, region: &str, forwarding_rule: &str) -> ForwardingRuleDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, region: &str, forwarding_rule: &str) -> ForwardingRuleDeleteCall<'a, C, A> { ForwardingRuleDeleteCall { hub: self.hub, _project: project.to_string(), @@ -6507,15 +6503,15 @@ impl<'a, C, NC, A> ForwardingRuleMethods<'a, C, NC, A> { /// let rb = hub.target_pools(); /// # } /// ``` -pub struct TargetPoolMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetPoolMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for TargetPoolMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TargetPoolMethods<'a, C, A> {} -impl<'a, C, NC, A> TargetPoolMethods<'a, C, NC, A> { +impl<'a, C, A> TargetPoolMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -6525,7 +6521,7 @@ impl<'a, C, NC, A> TargetPoolMethods<'a, C, NC, A> { /// /// * `project` - Name of the project scoping this request. /// * `region` - Name of the region scoping this request. - pub fn list(&self, project: &str, region: &str) -> TargetPoolListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, region: &str) -> TargetPoolListCall<'a, C, A> { TargetPoolListCall { hub: self.hub, _project: project.to_string(), @@ -6549,7 +6545,7 @@ impl<'a, C, NC, A> TargetPoolMethods<'a, C, NC, A> { /// * `project` - No description provided. /// * `region` - Name of the region scoping this request. /// * `targetPool` - Name of the TargetPool resource to which health_check_url is to be added. - pub fn add_health_check(&self, request: &TargetPoolsAddHealthCheckRequest, project: &str, region: &str, target_pool: &str) -> TargetPoolAddHealthCheckCall<'a, C, NC, A> { + pub fn add_health_check(&self, request: &TargetPoolsAddHealthCheckRequest, project: &str, region: &str, target_pool: &str) -> TargetPoolAddHealthCheckCall<'a, C, A> { TargetPoolAddHealthCheckCall { hub: self.hub, _request: request.clone(), @@ -6571,7 +6567,7 @@ impl<'a, C, NC, A> TargetPoolMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Name of the project scoping this request. /// * `region` - Name of the region scoping this request. - pub fn insert(&self, request: &TargetPool, project: &str, region: &str) -> TargetPoolInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &TargetPool, project: &str, region: &str) -> TargetPoolInsertCall<'a, C, A> { TargetPoolInsertCall { hub: self.hub, _request: request.clone(), @@ -6593,7 +6589,7 @@ impl<'a, C, NC, A> TargetPoolMethods<'a, C, NC, A> { /// * `project` - No description provided. /// * `region` - Name of the region scoping this request. /// * `targetPool` - Name of the TargetPool resource to which health_check_url is to be removed. - pub fn remove_health_check(&self, request: &TargetPoolsRemoveHealthCheckRequest, project: &str, region: &str, target_pool: &str) -> TargetPoolRemoveHealthCheckCall<'a, C, NC, A> { + pub fn remove_health_check(&self, request: &TargetPoolsRemoveHealthCheckRequest, project: &str, region: &str, target_pool: &str) -> TargetPoolRemoveHealthCheckCall<'a, C, A> { TargetPoolRemoveHealthCheckCall { hub: self.hub, _request: request.clone(), @@ -6616,7 +6612,7 @@ impl<'a, C, NC, A> TargetPoolMethods<'a, C, NC, A> { /// * `project` - No description provided. /// * `region` - Name of the region scoping this request. /// * `targetPool` - Name of the TargetPool resource to which the queried instance belongs. - pub fn get_health(&self, request: &InstanceReference, project: &str, region: &str, target_pool: &str) -> TargetPoolGetHealthCall<'a, C, NC, A> { + pub fn get_health(&self, request: &InstanceReference, project: &str, region: &str, target_pool: &str) -> TargetPoolGetHealthCall<'a, C, A> { TargetPoolGetHealthCall { hub: self.hub, _request: request.clone(), @@ -6639,7 +6635,7 @@ impl<'a, C, NC, A> TargetPoolMethods<'a, C, NC, A> { /// * `project` - Name of the project scoping this request. /// * `region` - Name of the region scoping this request. /// * `targetPool` - Name of the TargetPool resource for which the backup is to be set. - pub fn set_backup(&self, request: &TargetReference, project: &str, region: &str, target_pool: &str) -> TargetPoolSetBackupCall<'a, C, NC, A> { + pub fn set_backup(&self, request: &TargetReference, project: &str, region: &str, target_pool: &str) -> TargetPoolSetBackupCall<'a, C, A> { TargetPoolSetBackupCall { hub: self.hub, _request: request.clone(), @@ -6660,7 +6656,7 @@ impl<'a, C, NC, A> TargetPoolMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Name of the project scoping this request. - pub fn aggregated_list(&self, project: &str) -> TargetPoolAggregatedListCall<'a, C, NC, A> { + pub fn aggregated_list(&self, project: &str) -> TargetPoolAggregatedListCall<'a, C, A> { TargetPoolAggregatedListCall { hub: self.hub, _project: project.to_string(), @@ -6682,7 +6678,7 @@ impl<'a, C, NC, A> TargetPoolMethods<'a, C, NC, A> { /// * `project` - Name of the project scoping this request. /// * `region` - Name of the region scoping this request. /// * `targetPool` - Name of the TargetPool resource to return. - pub fn get(&self, project: &str, region: &str, target_pool: &str) -> TargetPoolGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, region: &str, target_pool: &str) -> TargetPoolGetCall<'a, C, A> { TargetPoolGetCall { hub: self.hub, _project: project.to_string(), @@ -6704,7 +6700,7 @@ impl<'a, C, NC, A> TargetPoolMethods<'a, C, NC, A> { /// * `project` - No description provided. /// * `region` - Name of the region scoping this request. /// * `targetPool` - Name of the TargetPool resource to which instance_url is to be added. - pub fn add_instance(&self, request: &TargetPoolsAddInstanceRequest, project: &str, region: &str, target_pool: &str) -> TargetPoolAddInstanceCall<'a, C, NC, A> { + pub fn add_instance(&self, request: &TargetPoolsAddInstanceRequest, project: &str, region: &str, target_pool: &str) -> TargetPoolAddInstanceCall<'a, C, A> { TargetPoolAddInstanceCall { hub: self.hub, _request: request.clone(), @@ -6727,7 +6723,7 @@ impl<'a, C, NC, A> TargetPoolMethods<'a, C, NC, A> { /// * `project` - No description provided. /// * `region` - Name of the region scoping this request. /// * `targetPool` - Name of the TargetPool resource to which instance_url is to be removed. - pub fn remove_instance(&self, request: &TargetPoolsRemoveInstanceRequest, project: &str, region: &str, target_pool: &str) -> TargetPoolRemoveInstanceCall<'a, C, NC, A> { + pub fn remove_instance(&self, request: &TargetPoolsRemoveInstanceRequest, project: &str, region: &str, target_pool: &str) -> TargetPoolRemoveInstanceCall<'a, C, A> { TargetPoolRemoveInstanceCall { hub: self.hub, _request: request.clone(), @@ -6749,7 +6745,7 @@ impl<'a, C, NC, A> TargetPoolMethods<'a, C, NC, A> { /// * `project` - Name of the project scoping this request. /// * `region` - Name of the region scoping this request. /// * `targetPool` - Name of the TargetPool resource to delete. - pub fn delete(&self, project: &str, region: &str, target_pool: &str) -> TargetPoolDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, region: &str, target_pool: &str) -> TargetPoolDeleteCall<'a, C, A> { TargetPoolDeleteCall { hub: self.hub, _project: project.to_string(), @@ -6792,15 +6788,15 @@ impl<'a, C, NC, A> TargetPoolMethods<'a, C, NC, A> { /// let rb = hub.target_instances(); /// # } /// ``` -pub struct TargetInstanceMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetInstanceMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for TargetInstanceMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TargetInstanceMethods<'a, C, A> {} -impl<'a, C, NC, A> TargetInstanceMethods<'a, C, NC, A> { +impl<'a, C, A> TargetInstanceMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -6810,7 +6806,7 @@ impl<'a, C, NC, A> TargetInstanceMethods<'a, C, NC, A> { /// /// * `project` - Name of the project scoping this request. /// * `zone` - Name of the zone scoping this request. - pub fn list(&self, project: &str, zone: &str) -> TargetInstanceListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, zone: &str) -> TargetInstanceListCall<'a, C, A> { TargetInstanceListCall { hub: self.hub, _project: project.to_string(), @@ -6833,7 +6829,7 @@ impl<'a, C, NC, A> TargetInstanceMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Name of the project scoping this request. /// * `zone` - Name of the zone scoping this request. - pub fn insert(&self, request: &TargetInstance, project: &str, zone: &str) -> TargetInstanceInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &TargetInstance, project: &str, zone: &str) -> TargetInstanceInsertCall<'a, C, A> { TargetInstanceInsertCall { hub: self.hub, _request: request.clone(), @@ -6852,7 +6848,7 @@ impl<'a, C, NC, A> TargetInstanceMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Name of the project scoping this request. - pub fn aggregated_list(&self, project: &str) -> TargetInstanceAggregatedListCall<'a, C, NC, A> { + pub fn aggregated_list(&self, project: &str) -> TargetInstanceAggregatedListCall<'a, C, A> { TargetInstanceAggregatedListCall { hub: self.hub, _project: project.to_string(), @@ -6874,7 +6870,7 @@ impl<'a, C, NC, A> TargetInstanceMethods<'a, C, NC, A> { /// * `project` - Name of the project scoping this request. /// * `zone` - Name of the zone scoping this request. /// * `targetInstance` - Name of the TargetInstance resource to return. - pub fn get(&self, project: &str, zone: &str, target_instance: &str) -> TargetInstanceGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, zone: &str, target_instance: &str) -> TargetInstanceGetCall<'a, C, A> { TargetInstanceGetCall { hub: self.hub, _project: project.to_string(), @@ -6895,7 +6891,7 @@ impl<'a, C, NC, A> TargetInstanceMethods<'a, C, NC, A> { /// * `project` - Name of the project scoping this request. /// * `zone` - Name of the zone scoping this request. /// * `targetInstance` - Name of the TargetInstance resource to delete. - pub fn delete(&self, project: &str, zone: &str, target_instance: &str) -> TargetInstanceDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, zone: &str, target_instance: &str) -> TargetInstanceDeleteCall<'a, C, A> { TargetInstanceDeleteCall { hub: self.hub, _project: project.to_string(), @@ -6938,15 +6934,15 @@ impl<'a, C, NC, A> TargetInstanceMethods<'a, C, NC, A> { /// let rb = hub.global_forwarding_rules(); /// # } /// ``` -pub struct GlobalForwardingRuleMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GlobalForwardingRuleMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for GlobalForwardingRuleMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for GlobalForwardingRuleMethods<'a, C, A> {} -impl<'a, C, NC, A> GlobalForwardingRuleMethods<'a, C, NC, A> { +impl<'a, C, A> GlobalForwardingRuleMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -6956,7 +6952,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleMethods<'a, C, NC, A> { /// /// * `project` - Name of the project scoping this request. /// * `forwardingRule` - Name of the ForwardingRule resource to return. - pub fn get(&self, project: &str, forwarding_rule: &str) -> GlobalForwardingRuleGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, forwarding_rule: &str) -> GlobalForwardingRuleGetCall<'a, C, A> { GlobalForwardingRuleGetCall { hub: self.hub, _project: project.to_string(), @@ -6975,7 +6971,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleMethods<'a, C, NC, A> { /// /// * `project` - Name of the project scoping this request. /// * `forwardingRule` - Name of the ForwardingRule resource to delete. - pub fn delete(&self, project: &str, forwarding_rule: &str) -> GlobalForwardingRuleDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, forwarding_rule: &str) -> GlobalForwardingRuleDeleteCall<'a, C, A> { GlobalForwardingRuleDeleteCall { hub: self.hub, _project: project.to_string(), @@ -6995,7 +6991,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Name of the project scoping this request. /// * `forwardingRule` - Name of the ForwardingRule resource in which target is to be set. - pub fn set_target(&self, request: &TargetReference, project: &str, forwarding_rule: &str) -> GlobalForwardingRuleSetTargetCall<'a, C, NC, A> { + pub fn set_target(&self, request: &TargetReference, project: &str, forwarding_rule: &str) -> GlobalForwardingRuleSetTargetCall<'a, C, A> { GlobalForwardingRuleSetTargetCall { hub: self.hub, _request: request.clone(), @@ -7015,7 +7011,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `project` - Name of the project scoping this request. - pub fn insert(&self, request: &ForwardingRule, project: &str) -> GlobalForwardingRuleInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &ForwardingRule, project: &str) -> GlobalForwardingRuleInsertCall<'a, C, A> { GlobalForwardingRuleInsertCall { hub: self.hub, _request: request.clone(), @@ -7033,7 +7029,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Name of the project scoping this request. - pub fn list(&self, project: &str) -> GlobalForwardingRuleListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> GlobalForwardingRuleListCall<'a, C, A> { GlobalForwardingRuleListCall { hub: self.hub, _project: project.to_string(), @@ -7077,15 +7073,15 @@ impl<'a, C, NC, A> GlobalForwardingRuleMethods<'a, C, NC, A> { /// let rb = hub.images(); /// # } /// ``` -pub struct ImageMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ImageMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for ImageMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ImageMethods<'a, C, A> {} -impl<'a, C, NC, A> ImageMethods<'a, C, NC, A> { +impl<'a, C, A> ImageMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -7094,7 +7090,7 @@ impl<'a, C, NC, A> ImageMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Project ID for this request. - pub fn list(&self, project: &str) -> ImageListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> ImageListCall<'a, C, A> { ImageListCall { hub: self.hub, _project: project.to_string(), @@ -7115,7 +7111,7 @@ impl<'a, C, NC, A> ImageMethods<'a, C, NC, A> { /// /// * `project` - Project ID for this request. /// * `image` - Name of the image resource to delete. - pub fn delete(&self, project: &str, image: &str) -> ImageDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, image: &str) -> ImageDeleteCall<'a, C, A> { ImageDeleteCall { hub: self.hub, _project: project.to_string(), @@ -7137,7 +7133,7 @@ impl<'a, C, NC, A> ImageMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Project ID for this request. /// * `image` - Image name. - pub fn deprecate(&self, request: &DeprecationStatus, project: &str, image: &str) -> ImageDeprecateCall<'a, C, NC, A> { + pub fn deprecate(&self, request: &DeprecationStatus, project: &str, image: &str) -> ImageDeprecateCall<'a, C, A> { ImageDeprecateCall { hub: self.hub, _request: request.clone(), @@ -7157,7 +7153,7 @@ impl<'a, C, NC, A> ImageMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `project` - Project ID for this request. - pub fn insert(&self, request: &Image, project: &str) -> ImageInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Image, project: &str) -> ImageInsertCall<'a, C, A> { ImageInsertCall { hub: self.hub, _request: request.clone(), @@ -7176,7 +7172,7 @@ impl<'a, C, NC, A> ImageMethods<'a, C, NC, A> { /// /// * `project` - Project ID for this request. /// * `image` - Name of the image resource to return. - pub fn get(&self, project: &str, image: &str) -> ImageGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, image: &str) -> ImageGetCall<'a, C, A> { ImageGetCall { hub: self.hub, _project: project.to_string(), @@ -7218,15 +7214,15 @@ impl<'a, C, NC, A> ImageMethods<'a, C, NC, A> { /// let rb = hub.machine_types(); /// # } /// ``` -pub struct MachineTypeMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MachineTypeMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for MachineTypeMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for MachineTypeMethods<'a, C, A> {} -impl<'a, C, NC, A> MachineTypeMethods<'a, C, NC, A> { +impl<'a, C, A> MachineTypeMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -7235,7 +7231,7 @@ impl<'a, C, NC, A> MachineTypeMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Project ID for this request. - pub fn aggregated_list(&self, project: &str) -> MachineTypeAggregatedListCall<'a, C, NC, A> { + pub fn aggregated_list(&self, project: &str) -> MachineTypeAggregatedListCall<'a, C, A> { MachineTypeAggregatedListCall { hub: self.hub, _project: project.to_string(), @@ -7257,7 +7253,7 @@ impl<'a, C, NC, A> MachineTypeMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `zone` - The name of the zone for this request. /// * `machineType` - Name of the machine type resource to return. - pub fn get(&self, project: &str, zone: &str, machine_type: &str) -> MachineTypeGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, zone: &str, machine_type: &str) -> MachineTypeGetCall<'a, C, A> { MachineTypeGetCall { hub: self.hub, _project: project.to_string(), @@ -7277,7 +7273,7 @@ impl<'a, C, NC, A> MachineTypeMethods<'a, C, NC, A> { /// /// * `project` - Project ID for this request. /// * `zone` - The name of the zone for this request. - pub fn list(&self, project: &str, zone: &str) -> MachineTypeListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, zone: &str) -> MachineTypeListCall<'a, C, A> { MachineTypeListCall { hub: self.hub, _project: project.to_string(), @@ -7322,15 +7318,15 @@ impl<'a, C, NC, A> MachineTypeMethods<'a, C, NC, A> { /// let rb = hub.target_vpn_gateways(); /// # } /// ``` -pub struct TargetVpnGatewayMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetVpnGatewayMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for TargetVpnGatewayMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TargetVpnGatewayMethods<'a, C, A> {} -impl<'a, C, NC, A> TargetVpnGatewayMethods<'a, C, NC, A> { +impl<'a, C, A> TargetVpnGatewayMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -7339,7 +7335,7 @@ impl<'a, C, NC, A> TargetVpnGatewayMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Project ID for this request. - pub fn aggregated_list(&self, project: &str) -> TargetVpnGatewayAggregatedListCall<'a, C, NC, A> { + pub fn aggregated_list(&self, project: &str) -> TargetVpnGatewayAggregatedListCall<'a, C, A> { TargetVpnGatewayAggregatedListCall { hub: self.hub, _project: project.to_string(), @@ -7361,7 +7357,7 @@ impl<'a, C, NC, A> TargetVpnGatewayMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `region` - The name of the region for this request. /// * `targetVpnGateway` - Name of the TargetVpnGateway resource to return. - pub fn get(&self, project: &str, region: &str, target_vpn_gateway: &str) -> TargetVpnGatewayGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, region: &str, target_vpn_gateway: &str) -> TargetVpnGatewayGetCall<'a, C, A> { TargetVpnGatewayGetCall { hub: self.hub, _project: project.to_string(), @@ -7381,7 +7377,7 @@ impl<'a, C, NC, A> TargetVpnGatewayMethods<'a, C, NC, A> { /// /// * `project` - Project ID for this request. /// * `region` - The name of the region for this request. - pub fn list(&self, project: &str, region: &str) -> TargetVpnGatewayListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, region: &str) -> TargetVpnGatewayListCall<'a, C, A> { TargetVpnGatewayListCall { hub: self.hub, _project: project.to_string(), @@ -7404,7 +7400,7 @@ impl<'a, C, NC, A> TargetVpnGatewayMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Project ID for this request. /// * `region` - The name of the region for this request. - pub fn insert(&self, request: &TargetVpnGateway, project: &str, region: &str) -> TargetVpnGatewayInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &TargetVpnGateway, project: &str, region: &str) -> TargetVpnGatewayInsertCall<'a, C, A> { TargetVpnGatewayInsertCall { hub: self.hub, _request: request.clone(), @@ -7425,7 +7421,7 @@ impl<'a, C, NC, A> TargetVpnGatewayMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `region` - The name of the region for this request. /// * `targetVpnGateway` - Name of the TargetVpnGateway resource to delete. - pub fn delete(&self, project: &str, region: &str, target_vpn_gateway: &str) -> TargetVpnGatewayDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, region: &str, target_vpn_gateway: &str) -> TargetVpnGatewayDeleteCall<'a, C, A> { TargetVpnGatewayDeleteCall { hub: self.hub, _project: project.to_string(), @@ -7468,15 +7464,15 @@ impl<'a, C, NC, A> TargetVpnGatewayMethods<'a, C, NC, A> { /// let rb = hub.projects(); /// # } /// ``` -pub struct ProjectMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for ProjectMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ProjectMethods<'a, C, A> {} -impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { +impl<'a, C, A> ProjectMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -7486,7 +7482,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `project` - Project ID for this request. - pub fn move_disk(&self, request: &DiskMoveRequest, project: &str) -> ProjectMoveDiskCall<'a, C, NC, A> { + pub fn move_disk(&self, request: &DiskMoveRequest, project: &str) -> ProjectMoveDiskCall<'a, C, A> { ProjectMoveDiskCall { hub: self.hub, _request: request.clone(), @@ -7505,7 +7501,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `project` - Project ID for this request. - pub fn set_common_instance_metadata(&self, request: &Metadata, project: &str) -> ProjectSetCommonInstanceMetadataCall<'a, C, NC, A> { + pub fn set_common_instance_metadata(&self, request: &Metadata, project: &str) -> ProjectSetCommonInstanceMetadataCall<'a, C, A> { ProjectSetCommonInstanceMetadataCall { hub: self.hub, _request: request.clone(), @@ -7523,7 +7519,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Project ID for this request. - pub fn get(&self, project: &str) -> ProjectGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str) -> ProjectGetCall<'a, C, A> { ProjectGetCall { hub: self.hub, _project: project.to_string(), @@ -7541,7 +7537,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `project` - Project ID for this request. - pub fn move_instance(&self, request: &InstanceMoveRequest, project: &str) -> ProjectMoveInstanceCall<'a, C, NC, A> { + pub fn move_instance(&self, request: &InstanceMoveRequest, project: &str) -> ProjectMoveInstanceCall<'a, C, A> { ProjectMoveInstanceCall { hub: self.hub, _request: request.clone(), @@ -7560,7 +7556,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `project` - Project ID for this request. - pub fn set_usage_export_bucket(&self, request: &UsageExportLocation, project: &str) -> ProjectSetUsageExportBucketCall<'a, C, NC, A> { + pub fn set_usage_export_bucket(&self, request: &UsageExportLocation, project: &str) -> ProjectSetUsageExportBucketCall<'a, C, A> { ProjectSetUsageExportBucketCall { hub: self.hub, _request: request.clone(), @@ -7602,15 +7598,15 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// let rb = hub.http_health_checks(); /// # } /// ``` -pub struct HttpHealthCheckMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct HttpHealthCheckMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for HttpHealthCheckMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for HttpHealthCheckMethods<'a, C, A> {} -impl<'a, C, NC, A> HttpHealthCheckMethods<'a, C, NC, A> { +impl<'a, C, A> HttpHealthCheckMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -7620,7 +7616,7 @@ impl<'a, C, NC, A> HttpHealthCheckMethods<'a, C, NC, A> { /// /// * `project` - Name of the project scoping this request. /// * `httpHealthCheck` - Name of the HttpHealthCheck resource to return. - pub fn get(&self, project: &str, http_health_check: &str) -> HttpHealthCheckGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, http_health_check: &str) -> HttpHealthCheckGetCall<'a, C, A> { HttpHealthCheckGetCall { hub: self.hub, _project: project.to_string(), @@ -7640,7 +7636,7 @@ impl<'a, C, NC, A> HttpHealthCheckMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Name of the project scoping this request. /// * `httpHealthCheck` - Name of the HttpHealthCheck resource to update. - pub fn patch(&self, request: &HttpHealthCheck, project: &str, http_health_check: &str) -> HttpHealthCheckPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &HttpHealthCheck, project: &str, http_health_check: &str) -> HttpHealthCheckPatchCall<'a, C, A> { HttpHealthCheckPatchCall { hub: self.hub, _request: request.clone(), @@ -7659,7 +7655,7 @@ impl<'a, C, NC, A> HttpHealthCheckMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Name of the project scoping this request. - pub fn list(&self, project: &str) -> HttpHealthCheckListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> HttpHealthCheckListCall<'a, C, A> { HttpHealthCheckListCall { hub: self.hub, _project: project.to_string(), @@ -7680,7 +7676,7 @@ impl<'a, C, NC, A> HttpHealthCheckMethods<'a, C, NC, A> { /// /// * `project` - Name of the project scoping this request. /// * `httpHealthCheck` - Name of the HttpHealthCheck resource to delete. - pub fn delete(&self, project: &str, http_health_check: &str) -> HttpHealthCheckDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, http_health_check: &str) -> HttpHealthCheckDeleteCall<'a, C, A> { HttpHealthCheckDeleteCall { hub: self.hub, _project: project.to_string(), @@ -7699,7 +7695,7 @@ impl<'a, C, NC, A> HttpHealthCheckMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `project` - Name of the project scoping this request. - pub fn insert(&self, request: &HttpHealthCheck, project: &str) -> HttpHealthCheckInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &HttpHealthCheck, project: &str) -> HttpHealthCheckInsertCall<'a, C, A> { HttpHealthCheckInsertCall { hub: self.hub, _request: request.clone(), @@ -7719,7 +7715,7 @@ impl<'a, C, NC, A> HttpHealthCheckMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Name of the project scoping this request. /// * `httpHealthCheck` - Name of the HttpHealthCheck resource to update. - pub fn update(&self, request: &HttpHealthCheck, project: &str, http_health_check: &str) -> HttpHealthCheckUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &HttpHealthCheck, project: &str, http_health_check: &str) -> HttpHealthCheckUpdateCall<'a, C, A> { HttpHealthCheckUpdateCall { hub: self.hub, _request: request.clone(), @@ -7762,15 +7758,15 @@ impl<'a, C, NC, A> HttpHealthCheckMethods<'a, C, NC, A> { /// let rb = hub.instance_templates(); /// # } /// ``` -pub struct InstanceTemplateMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceTemplateMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for InstanceTemplateMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for InstanceTemplateMethods<'a, C, A> {} -impl<'a, C, NC, A> InstanceTemplateMethods<'a, C, NC, A> { +impl<'a, C, A> InstanceTemplateMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -7780,7 +7776,7 @@ impl<'a, C, NC, A> InstanceTemplateMethods<'a, C, NC, A> { /// /// * `project` - Name of the project scoping this request. /// * `instanceTemplate` - Name of the instance template resource to delete. - pub fn delete(&self, project: &str, instance_template: &str) -> InstanceTemplateDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, instance_template: &str) -> InstanceTemplateDeleteCall<'a, C, A> { InstanceTemplateDeleteCall { hub: self.hub, _project: project.to_string(), @@ -7799,7 +7795,7 @@ impl<'a, C, NC, A> InstanceTemplateMethods<'a, C, NC, A> { /// /// * `project` - Name of the project scoping this request. /// * `instanceTemplate` - Name of the instance template resource to return. - pub fn get(&self, project: &str, instance_template: &str) -> InstanceTemplateGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, instance_template: &str) -> InstanceTemplateGetCall<'a, C, A> { InstanceTemplateGetCall { hub: self.hub, _project: project.to_string(), @@ -7817,7 +7813,7 @@ impl<'a, C, NC, A> InstanceTemplateMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Name of the project scoping this request. - pub fn list(&self, project: &str) -> InstanceTemplateListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> InstanceTemplateListCall<'a, C, A> { InstanceTemplateListCall { hub: self.hub, _project: project.to_string(), @@ -7838,7 +7834,7 @@ impl<'a, C, NC, A> InstanceTemplateMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `project` - Name of the project scoping this request. - pub fn insert(&self, request: &InstanceTemplate, project: &str) -> InstanceTemplateInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &InstanceTemplate, project: &str) -> InstanceTemplateInsertCall<'a, C, A> { InstanceTemplateInsertCall { hub: self.hub, _request: request.clone(), @@ -7880,15 +7876,15 @@ impl<'a, C, NC, A> InstanceTemplateMethods<'a, C, NC, A> { /// let rb = hub.target_http_proxies(); /// # } /// ``` -pub struct TargetHttpProxyMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetHttpProxyMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for TargetHttpProxyMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TargetHttpProxyMethods<'a, C, A> {} -impl<'a, C, NC, A> TargetHttpProxyMethods<'a, C, NC, A> { +impl<'a, C, A> TargetHttpProxyMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -7898,7 +7894,7 @@ impl<'a, C, NC, A> TargetHttpProxyMethods<'a, C, NC, A> { /// /// * `project` - Name of the project scoping this request. /// * `targetHttpProxy` - Name of the TargetHttpProxy resource to delete. - pub fn delete(&self, project: &str, target_http_proxy: &str) -> TargetHttpProxyDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, target_http_proxy: &str) -> TargetHttpProxyDeleteCall<'a, C, A> { TargetHttpProxyDeleteCall { hub: self.hub, _project: project.to_string(), @@ -7916,7 +7912,7 @@ impl<'a, C, NC, A> TargetHttpProxyMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Name of the project scoping this request. - pub fn list(&self, project: &str) -> TargetHttpProxyListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> TargetHttpProxyListCall<'a, C, A> { TargetHttpProxyListCall { hub: self.hub, _project: project.to_string(), @@ -7937,7 +7933,7 @@ impl<'a, C, NC, A> TargetHttpProxyMethods<'a, C, NC, A> { /// /// * `project` - Name of the project scoping this request. /// * `targetHttpProxy` - Name of the TargetHttpProxy resource to return. - pub fn get(&self, project: &str, target_http_proxy: &str) -> TargetHttpProxyGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, target_http_proxy: &str) -> TargetHttpProxyGetCall<'a, C, A> { TargetHttpProxyGetCall { hub: self.hub, _project: project.to_string(), @@ -7957,7 +7953,7 @@ impl<'a, C, NC, A> TargetHttpProxyMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Name of the project scoping this request. /// * `targetHttpProxy` - Name of the TargetHttpProxy resource whose URL map is to be set. - pub fn set_url_map(&self, request: &UrlMapReference, project: &str, target_http_proxy: &str) -> TargetHttpProxySetUrlMapCall<'a, C, NC, A> { + pub fn set_url_map(&self, request: &UrlMapReference, project: &str, target_http_proxy: &str) -> TargetHttpProxySetUrlMapCall<'a, C, A> { TargetHttpProxySetUrlMapCall { hub: self.hub, _request: request.clone(), @@ -7977,7 +7973,7 @@ impl<'a, C, NC, A> TargetHttpProxyMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `project` - Name of the project scoping this request. - pub fn insert(&self, request: &TargetHttpProxy, project: &str) -> TargetHttpProxyInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &TargetHttpProxy, project: &str) -> TargetHttpProxyInsertCall<'a, C, A> { TargetHttpProxyInsertCall { hub: self.hub, _request: request.clone(), @@ -8019,15 +8015,15 @@ impl<'a, C, NC, A> TargetHttpProxyMethods<'a, C, NC, A> { /// let rb = hub.zone_operations(); /// # } /// ``` -pub struct ZoneOperationMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneOperationMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for ZoneOperationMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ZoneOperationMethods<'a, C, A> {} -impl<'a, C, NC, A> ZoneOperationMethods<'a, C, NC, A> { +impl<'a, C, A> ZoneOperationMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -8038,7 +8034,7 @@ impl<'a, C, NC, A> ZoneOperationMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `zone` - Name of the zone scoping this request. /// * `operation` - Name of the operation resource to delete. - pub fn delete(&self, project: &str, zone: &str, operation: &str) -> ZoneOperationDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, zone: &str, operation: &str) -> ZoneOperationDeleteCall<'a, C, A> { ZoneOperationDeleteCall { hub: self.hub, _project: project.to_string(), @@ -8058,7 +8054,7 @@ impl<'a, C, NC, A> ZoneOperationMethods<'a, C, NC, A> { /// /// * `project` - Project ID for this request. /// * `zone` - Name of the zone scoping this request. - pub fn list(&self, project: &str, zone: &str) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, zone: &str) -> ZoneOperationListCall<'a, C, A> { ZoneOperationListCall { hub: self.hub, _project: project.to_string(), @@ -8081,7 +8077,7 @@ impl<'a, C, NC, A> ZoneOperationMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `zone` - Name of the zone scoping this request. /// * `operation` - Name of the operation resource to return. - pub fn get(&self, project: &str, zone: &str, operation: &str) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, zone: &str, operation: &str) -> ZoneOperationGetCall<'a, C, A> { ZoneOperationGetCall { hub: self.hub, _project: project.to_string(), @@ -8124,15 +8120,15 @@ impl<'a, C, NC, A> ZoneOperationMethods<'a, C, NC, A> { /// let rb = hub.routes(); /// # } /// ``` -pub struct RouteMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RouteMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for RouteMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for RouteMethods<'a, C, A> {} -impl<'a, C, NC, A> RouteMethods<'a, C, NC, A> { +impl<'a, C, A> RouteMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -8142,7 +8138,7 @@ impl<'a, C, NC, A> RouteMethods<'a, C, NC, A> { /// /// * `project` - Name of the project scoping this request. /// * `route` - Name of the route resource to return. - pub fn get(&self, project: &str, route: &str) -> RouteGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, route: &str) -> RouteGetCall<'a, C, A> { RouteGetCall { hub: self.hub, _project: project.to_string(), @@ -8161,7 +8157,7 @@ impl<'a, C, NC, A> RouteMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `project` - Name of the project scoping this request. - pub fn insert(&self, request: &Route, project: &str) -> RouteInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Route, project: &str) -> RouteInsertCall<'a, C, A> { RouteInsertCall { hub: self.hub, _request: request.clone(), @@ -8179,7 +8175,7 @@ impl<'a, C, NC, A> RouteMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Name of the project scoping this request. - pub fn list(&self, project: &str) -> RouteListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> RouteListCall<'a, C, A> { RouteListCall { hub: self.hub, _project: project.to_string(), @@ -8200,7 +8196,7 @@ impl<'a, C, NC, A> RouteMethods<'a, C, NC, A> { /// /// * `project` - Name of the project scoping this request. /// * `route` - Name of the route resource to delete. - pub fn delete(&self, project: &str, route: &str) -> RouteDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, route: &str) -> RouteDeleteCall<'a, C, A> { RouteDeleteCall { hub: self.hub, _project: project.to_string(), @@ -8242,15 +8238,15 @@ impl<'a, C, NC, A> RouteMethods<'a, C, NC, A> { /// let rb = hub.firewalls(); /// # } /// ``` -pub struct FirewallMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FirewallMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for FirewallMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for FirewallMethods<'a, C, A> {} -impl<'a, C, NC, A> FirewallMethods<'a, C, NC, A> { +impl<'a, C, A> FirewallMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -8261,7 +8257,7 @@ impl<'a, C, NC, A> FirewallMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Project ID for this request. /// * `firewall` - Name of the firewall resource to update. - pub fn patch(&self, request: &Firewall, project: &str, firewall: &str) -> FirewallPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Firewall, project: &str, firewall: &str) -> FirewallPatchCall<'a, C, A> { FirewallPatchCall { hub: self.hub, _request: request.clone(), @@ -8281,7 +8277,7 @@ impl<'a, C, NC, A> FirewallMethods<'a, C, NC, A> { /// /// * `project` - Project ID for this request. /// * `firewall` - Name of the firewall resource to return. - pub fn get(&self, project: &str, firewall: &str) -> FirewallGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, firewall: &str) -> FirewallGetCall<'a, C, A> { FirewallGetCall { hub: self.hub, _project: project.to_string(), @@ -8300,7 +8296,7 @@ impl<'a, C, NC, A> FirewallMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `project` - Project ID for this request. - pub fn insert(&self, request: &Firewall, project: &str) -> FirewallInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Firewall, project: &str) -> FirewallInsertCall<'a, C, A> { FirewallInsertCall { hub: self.hub, _request: request.clone(), @@ -8320,7 +8316,7 @@ impl<'a, C, NC, A> FirewallMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Project ID for this request. /// * `firewall` - Name of the firewall resource to update. - pub fn update(&self, request: &Firewall, project: &str, firewall: &str) -> FirewallUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Firewall, project: &str, firewall: &str) -> FirewallUpdateCall<'a, C, A> { FirewallUpdateCall { hub: self.hub, _request: request.clone(), @@ -8340,7 +8336,7 @@ impl<'a, C, NC, A> FirewallMethods<'a, C, NC, A> { /// /// * `project` - Project ID for this request. /// * `firewall` - Name of the firewall resource to delete. - pub fn delete(&self, project: &str, firewall: &str) -> FirewallDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, firewall: &str) -> FirewallDeleteCall<'a, C, A> { FirewallDeleteCall { hub: self.hub, _project: project.to_string(), @@ -8358,7 +8354,7 @@ impl<'a, C, NC, A> FirewallMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Project ID for this request. - pub fn list(&self, project: &str) -> FirewallListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> FirewallListCall<'a, C, A> { FirewallListCall { hub: self.hub, _project: project.to_string(), @@ -8402,15 +8398,15 @@ impl<'a, C, NC, A> FirewallMethods<'a, C, NC, A> { /// let rb = hub.vpn_tunnels(); /// # } /// ``` -pub struct VpnTunnelMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VpnTunnelMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for VpnTunnelMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for VpnTunnelMethods<'a, C, A> {} -impl<'a, C, NC, A> VpnTunnelMethods<'a, C, NC, A> { +impl<'a, C, A> VpnTunnelMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -8421,7 +8417,7 @@ impl<'a, C, NC, A> VpnTunnelMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `region` - The name of the region for this request. /// * `vpnTunnel` - Name of the VpnTunnel resource to delete. - pub fn delete(&self, project: &str, region: &str, vpn_tunnel: &str) -> VpnTunnelDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, region: &str, vpn_tunnel: &str) -> VpnTunnelDeleteCall<'a, C, A> { VpnTunnelDeleteCall { hub: self.hub, _project: project.to_string(), @@ -8441,7 +8437,7 @@ impl<'a, C, NC, A> VpnTunnelMethods<'a, C, NC, A> { /// /// * `project` - Project ID for this request. /// * `region` - The name of the region for this request. - pub fn list(&self, project: &str, region: &str) -> VpnTunnelListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, region: &str) -> VpnTunnelListCall<'a, C, A> { VpnTunnelListCall { hub: self.hub, _project: project.to_string(), @@ -8464,7 +8460,7 @@ impl<'a, C, NC, A> VpnTunnelMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `region` - The name of the region for this request. /// * `vpnTunnel` - Name of the VpnTunnel resource to return. - pub fn get(&self, project: &str, region: &str, vpn_tunnel: &str) -> VpnTunnelGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, region: &str, vpn_tunnel: &str) -> VpnTunnelGetCall<'a, C, A> { VpnTunnelGetCall { hub: self.hub, _project: project.to_string(), @@ -8485,7 +8481,7 @@ impl<'a, C, NC, A> VpnTunnelMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Project ID for this request. /// * `region` - The name of the region for this request. - pub fn insert(&self, request: &VpnTunnel, project: &str, region: &str) -> VpnTunnelInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &VpnTunnel, project: &str, region: &str) -> VpnTunnelInsertCall<'a, C, A> { VpnTunnelInsertCall { hub: self.hub, _request: request.clone(), @@ -8504,7 +8500,7 @@ impl<'a, C, NC, A> VpnTunnelMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Project ID for this request. - pub fn aggregated_list(&self, project: &str) -> VpnTunnelAggregatedListCall<'a, C, NC, A> { + pub fn aggregated_list(&self, project: &str) -> VpnTunnelAggregatedListCall<'a, C, A> { VpnTunnelAggregatedListCall { hub: self.hub, _project: project.to_string(), @@ -8548,15 +8544,15 @@ impl<'a, C, NC, A> VpnTunnelMethods<'a, C, NC, A> { /// let rb = hub.region_operations(); /// # } /// ``` -pub struct RegionOperationMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RegionOperationMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, } -impl<'a, C, NC, A> MethodsBuilder for RegionOperationMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for RegionOperationMethods<'a, C, A> {} -impl<'a, C, NC, A> RegionOperationMethods<'a, C, NC, A> { +impl<'a, C, A> RegionOperationMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -8566,7 +8562,7 @@ impl<'a, C, NC, A> RegionOperationMethods<'a, C, NC, A> { /// /// * `project` - Project ID for this request. /// * `region` - Name of the region scoping this request. - pub fn list(&self, project: &str, region: &str) -> RegionOperationListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, region: &str) -> RegionOperationListCall<'a, C, A> { RegionOperationListCall { hub: self.hub, _project: project.to_string(), @@ -8589,7 +8585,7 @@ impl<'a, C, NC, A> RegionOperationMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `region` - Name of the region scoping this request. /// * `operation` - Name of the operation resource to delete. - pub fn delete(&self, project: &str, region: &str, operation: &str) -> RegionOperationDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, region: &str, operation: &str) -> RegionOperationDeleteCall<'a, C, A> { RegionOperationDeleteCall { hub: self.hub, _project: project.to_string(), @@ -8610,7 +8606,7 @@ impl<'a, C, NC, A> RegionOperationMethods<'a, C, NC, A> { /// * `project` - Project ID for this request. /// * `region` - Name of the zone scoping this request. /// * `operation` - Name of the operation resource to return. - pub fn get(&self, project: &str, region: &str, operation: &str) -> RegionOperationGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, region: &str, operation: &str) -> RegionOperationGetCall<'a, C, A> { RegionOperationGetCall { hub: self.hub, _project: project.to_string(), @@ -8661,10 +8657,10 @@ impl<'a, C, NC, A> RegionOperationMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct DiskDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DiskDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _disk: String, @@ -8673,9 +8669,9 @@ pub struct DiskDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DiskDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DiskDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> DiskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DiskDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8809,7 +8805,7 @@ impl<'a, C, NC, A> DiskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> DiskDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> DiskDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -8819,7 +8815,7 @@ impl<'a, C, NC, A> DiskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> DiskDeleteCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> DiskDeleteCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -8829,7 +8825,7 @@ impl<'a, C, NC, A> DiskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Name of the persistent disk to delete. - pub fn disk(mut self, new_value: &str) -> DiskDeleteCall<'a, C, NC, A> { + pub fn disk(mut self, new_value: &str) -> DiskDeleteCall<'a, C, A> { self._disk = new_value.to_string(); self } @@ -8840,7 +8836,7 @@ impl<'a, C, NC, A> DiskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DiskDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DiskDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8861,7 +8857,7 @@ impl<'a, C, NC, A> DiskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DiskDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DiskDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8878,7 +8874,7 @@ impl<'a, C, NC, A> DiskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DiskDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DiskDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8919,10 +8915,10 @@ impl<'a, C, NC, A> DiskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct DiskAggregatedListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DiskAggregatedListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -8932,9 +8928,9 @@ pub struct DiskAggregatedListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DiskAggregatedListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DiskAggregatedListCall<'a, C, A> {} -impl<'a, C, NC, A> DiskAggregatedListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DiskAggregatedListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9075,7 +9071,7 @@ impl<'a, C, NC, A> DiskAggregatedListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> DiskAggregatedListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> DiskAggregatedListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -9083,7 +9079,7 @@ impl<'a, C, NC, A> DiskAggregatedListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> DiskAggregatedListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> DiskAggregatedListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -9091,7 +9087,7 @@ impl<'a, C, NC, A> DiskAggregatedListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> DiskAggregatedListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> DiskAggregatedListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -9099,7 +9095,7 @@ impl<'a, C, NC, A> DiskAggregatedListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> DiskAggregatedListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> DiskAggregatedListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -9110,7 +9106,7 @@ impl<'a, C, NC, A> DiskAggregatedListCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DiskAggregatedListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DiskAggregatedListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9131,7 +9127,7 @@ impl<'a, C, NC, A> DiskAggregatedListCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DiskAggregatedListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DiskAggregatedListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9148,7 +9144,7 @@ impl<'a, C, NC, A> DiskAggregatedListCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DiskAggregatedListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DiskAggregatedListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9189,10 +9185,10 @@ impl<'a, C, NC, A> DiskAggregatedListCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct DiskListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DiskListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _page_token: Option, @@ -9203,9 +9199,9 @@ pub struct DiskListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DiskListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DiskListCall<'a, C, A> {} -impl<'a, C, NC, A> DiskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DiskListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9347,7 +9343,7 @@ impl<'a, C, NC, A> DiskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> DiskListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> DiskListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -9357,7 +9353,7 @@ impl<'a, C, NC, A> DiskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> DiskListCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> DiskListCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -9365,7 +9361,7 @@ impl<'a, C, NC, A> DiskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> DiskListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> DiskListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -9373,7 +9369,7 @@ impl<'a, C, NC, A> DiskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> DiskListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> DiskListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -9381,7 +9377,7 @@ impl<'a, C, NC, A> DiskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> DiskListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> DiskListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -9392,7 +9388,7 @@ impl<'a, C, NC, A> DiskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DiskListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DiskListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9413,7 +9409,7 @@ impl<'a, C, NC, A> DiskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DiskListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DiskListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9430,7 +9426,7 @@ impl<'a, C, NC, A> DiskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DiskListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DiskListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9475,10 +9471,10 @@ impl<'a, C, NC, A> DiskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct DiskInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DiskInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: Disk, _project: String, _zone: String, @@ -9488,9 +9484,9 @@ pub struct DiskInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DiskInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DiskInsertCall<'a, C, A> {} -impl<'a, C, NC, A> DiskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DiskInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9633,7 +9629,7 @@ impl<'a, C, NC, A> DiskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Disk) -> DiskInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Disk) -> DiskInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9643,7 +9639,7 @@ impl<'a, C, NC, A> DiskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> DiskInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> DiskInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -9653,7 +9649,7 @@ impl<'a, C, NC, A> DiskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> DiskInsertCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> DiskInsertCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -9661,7 +9657,7 @@ impl<'a, C, NC, A> DiskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Optional. Source image to restore onto a disk. - pub fn source_image(mut self, new_value: &str) -> DiskInsertCall<'a, C, NC, A> { + pub fn source_image(mut self, new_value: &str) -> DiskInsertCall<'a, C, A> { self._source_image = Some(new_value.to_string()); self } @@ -9672,7 +9668,7 @@ impl<'a, C, NC, A> DiskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DiskInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DiskInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9693,7 +9689,7 @@ impl<'a, C, NC, A> DiskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DiskInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DiskInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9710,7 +9706,7 @@ impl<'a, C, NC, A> DiskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DiskInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DiskInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9754,10 +9750,10 @@ impl<'a, C, NC, A> DiskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct DiskCreateSnapshotCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DiskCreateSnapshotCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: Snapshot, _project: String, _zone: String, @@ -9767,9 +9763,9 @@ pub struct DiskCreateSnapshotCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DiskCreateSnapshotCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DiskCreateSnapshotCall<'a, C, A> {} -impl<'a, C, NC, A> DiskCreateSnapshotCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DiskCreateSnapshotCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9910,7 +9906,7 @@ impl<'a, C, NC, A> DiskCreateSnapshotCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Snapshot) -> DiskCreateSnapshotCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Snapshot) -> DiskCreateSnapshotCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9920,7 +9916,7 @@ impl<'a, C, NC, A> DiskCreateSnapshotCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> DiskCreateSnapshotCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> DiskCreateSnapshotCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -9930,7 +9926,7 @@ impl<'a, C, NC, A> DiskCreateSnapshotCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> DiskCreateSnapshotCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> DiskCreateSnapshotCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -9940,7 +9936,7 @@ impl<'a, C, NC, A> DiskCreateSnapshotCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Name of the persistent disk to snapshot. - pub fn disk(mut self, new_value: &str) -> DiskCreateSnapshotCall<'a, C, NC, A> { + pub fn disk(mut self, new_value: &str) -> DiskCreateSnapshotCall<'a, C, A> { self._disk = new_value.to_string(); self } @@ -9951,7 +9947,7 @@ impl<'a, C, NC, A> DiskCreateSnapshotCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DiskCreateSnapshotCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DiskCreateSnapshotCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9972,7 +9968,7 @@ impl<'a, C, NC, A> DiskCreateSnapshotCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DiskCreateSnapshotCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DiskCreateSnapshotCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9989,7 +9985,7 @@ impl<'a, C, NC, A> DiskCreateSnapshotCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DiskCreateSnapshotCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DiskCreateSnapshotCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10027,10 +10023,10 @@ impl<'a, C, NC, A> DiskCreateSnapshotCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct DiskGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DiskGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _disk: String, @@ -10039,9 +10035,9 @@ pub struct DiskGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DiskGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DiskGetCall<'a, C, A> {} -impl<'a, C, NC, A> DiskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DiskGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10175,7 +10171,7 @@ impl<'a, C, NC, A> DiskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> DiskGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> DiskGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -10185,7 +10181,7 @@ impl<'a, C, NC, A> DiskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> DiskGetCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> DiskGetCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -10195,7 +10191,7 @@ impl<'a, C, NC, A> DiskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// Name of the persistent disk to return. - pub fn disk(mut self, new_value: &str) -> DiskGetCall<'a, C, NC, A> { + pub fn disk(mut self, new_value: &str) -> DiskGetCall<'a, C, A> { self._disk = new_value.to_string(); self } @@ -10206,7 +10202,7 @@ impl<'a, C, NC, A> DiskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DiskGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DiskGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10227,7 +10223,7 @@ impl<'a, C, NC, A> DiskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DiskGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DiskGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10244,7 +10240,7 @@ impl<'a, C, NC, A> DiskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DiskGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DiskGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10285,10 +10281,10 @@ impl<'a, C, NC, A> DiskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct AddresseListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AddresseListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _region: String, _page_token: Option, @@ -10299,9 +10295,9 @@ pub struct AddresseListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AddresseListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AddresseListCall<'a, C, A> {} -impl<'a, C, NC, A> AddresseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AddresseListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10443,7 +10439,7 @@ impl<'a, C, NC, A> AddresseListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> AddresseListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> AddresseListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -10453,7 +10449,7 @@ impl<'a, C, NC, A> AddresseListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The name of the region for this request. - pub fn region(mut self, new_value: &str) -> AddresseListCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> AddresseListCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -10461,7 +10457,7 @@ impl<'a, C, NC, A> AddresseListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> AddresseListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AddresseListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -10469,7 +10465,7 @@ impl<'a, C, NC, A> AddresseListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> AddresseListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> AddresseListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -10477,7 +10473,7 @@ impl<'a, C, NC, A> AddresseListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> AddresseListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> AddresseListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -10488,7 +10484,7 @@ impl<'a, C, NC, A> AddresseListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AddresseListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AddresseListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10509,7 +10505,7 @@ impl<'a, C, NC, A> AddresseListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AddresseListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AddresseListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10526,7 +10522,7 @@ impl<'a, C, NC, A> AddresseListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AddresseListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AddresseListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10567,10 +10563,10 @@ impl<'a, C, NC, A> AddresseListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct AddresseAggregatedListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AddresseAggregatedListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -10580,9 +10576,9 @@ pub struct AddresseAggregatedListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AddresseAggregatedListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AddresseAggregatedListCall<'a, C, A> {} -impl<'a, C, NC, A> AddresseAggregatedListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AddresseAggregatedListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10723,7 +10719,7 @@ impl<'a, C, NC, A> AddresseAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> AddresseAggregatedListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> AddresseAggregatedListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -10731,7 +10727,7 @@ impl<'a, C, NC, A> AddresseAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> AddresseAggregatedListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AddresseAggregatedListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -10739,7 +10735,7 @@ impl<'a, C, NC, A> AddresseAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> AddresseAggregatedListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> AddresseAggregatedListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -10747,7 +10743,7 @@ impl<'a, C, NC, A> AddresseAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> AddresseAggregatedListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> AddresseAggregatedListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -10758,7 +10754,7 @@ impl<'a, C, NC, A> AddresseAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AddresseAggregatedListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AddresseAggregatedListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10779,7 +10775,7 @@ impl<'a, C, NC, A> AddresseAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AddresseAggregatedListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AddresseAggregatedListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10796,7 +10792,7 @@ impl<'a, C, NC, A> AddresseAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AddresseAggregatedListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AddresseAggregatedListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10834,10 +10830,10 @@ impl<'a, C, NC, A> AddresseAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct AddresseGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AddresseGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _region: String, _address: String, @@ -10846,9 +10842,9 @@ pub struct AddresseGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AddresseGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AddresseGetCall<'a, C, A> {} -impl<'a, C, NC, A> AddresseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AddresseGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10982,7 +10978,7 @@ impl<'a, C, NC, A> AddresseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> AddresseGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> AddresseGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -10992,7 +10988,7 @@ impl<'a, C, NC, A> AddresseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The name of the region for this request. - pub fn region(mut self, new_value: &str) -> AddresseGetCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> AddresseGetCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -11002,7 +10998,7 @@ impl<'a, C, NC, A> AddresseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Name of the address resource to return. - pub fn address(mut self, new_value: &str) -> AddresseGetCall<'a, C, NC, A> { + pub fn address(mut self, new_value: &str) -> AddresseGetCall<'a, C, A> { self._address = new_value.to_string(); self } @@ -11013,7 +11009,7 @@ impl<'a, C, NC, A> AddresseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AddresseGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AddresseGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11034,7 +11030,7 @@ impl<'a, C, NC, A> AddresseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AddresseGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AddresseGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11051,7 +11047,7 @@ impl<'a, C, NC, A> AddresseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AddresseGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AddresseGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11095,10 +11091,10 @@ impl<'a, C, NC, A> AddresseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct AddresseInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AddresseInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: Address, _project: String, _region: String, @@ -11107,9 +11103,9 @@ pub struct AddresseInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AddresseInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AddresseInsertCall<'a, C, A> {} -impl<'a, C, NC, A> AddresseInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AddresseInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11249,7 +11245,7 @@ impl<'a, C, NC, A> AddresseInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Address) -> AddresseInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Address) -> AddresseInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -11259,7 +11255,7 @@ impl<'a, C, NC, A> AddresseInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> AddresseInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> AddresseInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -11269,7 +11265,7 @@ impl<'a, C, NC, A> AddresseInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The name of the region for this request. - pub fn region(mut self, new_value: &str) -> AddresseInsertCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> AddresseInsertCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -11280,7 +11276,7 @@ impl<'a, C, NC, A> AddresseInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AddresseInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AddresseInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11301,7 +11297,7 @@ impl<'a, C, NC, A> AddresseInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AddresseInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AddresseInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11318,7 +11314,7 @@ impl<'a, C, NC, A> AddresseInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AddresseInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AddresseInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11356,10 +11352,10 @@ impl<'a, C, NC, A> AddresseInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct AddresseDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AddresseDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _region: String, _address: String, @@ -11368,9 +11364,9 @@ pub struct AddresseDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AddresseDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AddresseDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> AddresseDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AddresseDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11504,7 +11500,7 @@ impl<'a, C, NC, A> AddresseDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> AddresseDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> AddresseDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -11514,7 +11510,7 @@ impl<'a, C, NC, A> AddresseDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The name of the region for this request. - pub fn region(mut self, new_value: &str) -> AddresseDeleteCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> AddresseDeleteCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -11524,7 +11520,7 @@ impl<'a, C, NC, A> AddresseDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Name of the address resource to delete. - pub fn address(mut self, new_value: &str) -> AddresseDeleteCall<'a, C, NC, A> { + pub fn address(mut self, new_value: &str) -> AddresseDeleteCall<'a, C, A> { self._address = new_value.to_string(); self } @@ -11535,7 +11531,7 @@ impl<'a, C, NC, A> AddresseDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AddresseDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AddresseDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11556,7 +11552,7 @@ impl<'a, C, NC, A> AddresseDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AddresseDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AddresseDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11573,7 +11569,7 @@ impl<'a, C, NC, A> AddresseDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AddresseDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AddresseDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11617,10 +11613,10 @@ impl<'a, C, NC, A> AddresseDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct UrlMapInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlMapInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: UrlMap, _project: String, _delegate: Option<&'a mut Delegate>, @@ -11628,9 +11624,9 @@ pub struct UrlMapInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UrlMapInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UrlMapInsertCall<'a, C, A> {} -impl<'a, C, NC, A> UrlMapInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UrlMapInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11769,7 +11765,7 @@ impl<'a, C, NC, A> UrlMapInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &UrlMap) -> UrlMapInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &UrlMap) -> UrlMapInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -11779,7 +11775,7 @@ impl<'a, C, NC, A> UrlMapInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> UrlMapInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> UrlMapInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -11790,7 +11786,7 @@ impl<'a, C, NC, A> UrlMapInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlMapInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlMapInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11811,7 +11807,7 @@ impl<'a, C, NC, A> UrlMapInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UrlMapInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UrlMapInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11828,7 +11824,7 @@ impl<'a, C, NC, A> UrlMapInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UrlMapInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UrlMapInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11866,10 +11862,10 @@ impl<'a, C, NC, A> UrlMapInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct UrlMapGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlMapGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _url_map: String, _delegate: Option<&'a mut Delegate>, @@ -11877,9 +11873,9 @@ pub struct UrlMapGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UrlMapGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UrlMapGetCall<'a, C, A> {} -impl<'a, C, NC, A> UrlMapGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UrlMapGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12012,7 +12008,7 @@ impl<'a, C, NC, A> UrlMapGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> UrlMapGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> UrlMapGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -12022,7 +12018,7 @@ impl<'a, C, NC, A> UrlMapGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Name of the UrlMap resource to return. - pub fn url_map(mut self, new_value: &str) -> UrlMapGetCall<'a, C, NC, A> { + pub fn url_map(mut self, new_value: &str) -> UrlMapGetCall<'a, C, A> { self._url_map = new_value.to_string(); self } @@ -12033,7 +12029,7 @@ impl<'a, C, NC, A> UrlMapGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlMapGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlMapGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12054,7 +12050,7 @@ impl<'a, C, NC, A> UrlMapGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UrlMapGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UrlMapGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12071,7 +12067,7 @@ impl<'a, C, NC, A> UrlMapGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UrlMapGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UrlMapGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12115,10 +12111,10 @@ impl<'a, C, NC, A> UrlMapGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct UrlMapValidateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlMapValidateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: UrlMapsValidateRequest, _project: String, _url_map: String, @@ -12127,9 +12123,9 @@ pub struct UrlMapValidateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UrlMapValidateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UrlMapValidateCall<'a, C, A> {} -impl<'a, C, NC, A> UrlMapValidateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UrlMapValidateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12269,7 +12265,7 @@ impl<'a, C, NC, A> UrlMapValidateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &UrlMapsValidateRequest) -> UrlMapValidateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &UrlMapsValidateRequest) -> UrlMapValidateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -12279,7 +12275,7 @@ impl<'a, C, NC, A> UrlMapValidateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> UrlMapValidateCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> UrlMapValidateCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -12289,7 +12285,7 @@ impl<'a, C, NC, A> UrlMapValidateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Name of the UrlMap resource to be validated as. - pub fn url_map(mut self, new_value: &str) -> UrlMapValidateCall<'a, C, NC, A> { + pub fn url_map(mut self, new_value: &str) -> UrlMapValidateCall<'a, C, A> { self._url_map = new_value.to_string(); self } @@ -12300,7 +12296,7 @@ impl<'a, C, NC, A> UrlMapValidateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlMapValidateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlMapValidateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12321,7 +12317,7 @@ impl<'a, C, NC, A> UrlMapValidateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UrlMapValidateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UrlMapValidateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12338,7 +12334,7 @@ impl<'a, C, NC, A> UrlMapValidateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UrlMapValidateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UrlMapValidateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12379,10 +12375,10 @@ impl<'a, C, NC, A> UrlMapValidateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct UrlMapListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlMapListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -12392,9 +12388,9 @@ pub struct UrlMapListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UrlMapListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UrlMapListCall<'a, C, A> {} -impl<'a, C, NC, A> UrlMapListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UrlMapListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12535,7 +12531,7 @@ impl<'a, C, NC, A> UrlMapListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> UrlMapListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> UrlMapListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -12543,7 +12539,7 @@ impl<'a, C, NC, A> UrlMapListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> UrlMapListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> UrlMapListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -12551,7 +12547,7 @@ impl<'a, C, NC, A> UrlMapListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> UrlMapListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> UrlMapListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -12559,7 +12555,7 @@ impl<'a, C, NC, A> UrlMapListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> UrlMapListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> UrlMapListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -12570,7 +12566,7 @@ impl<'a, C, NC, A> UrlMapListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlMapListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlMapListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12591,7 +12587,7 @@ impl<'a, C, NC, A> UrlMapListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UrlMapListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UrlMapListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12608,7 +12604,7 @@ impl<'a, C, NC, A> UrlMapListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UrlMapListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UrlMapListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12652,10 +12648,10 @@ impl<'a, C, NC, A> UrlMapListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct UrlMapPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlMapPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: UrlMap, _project: String, _url_map: String, @@ -12664,9 +12660,9 @@ pub struct UrlMapPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UrlMapPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UrlMapPatchCall<'a, C, A> {} -impl<'a, C, NC, A> UrlMapPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UrlMapPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12806,7 +12802,7 @@ impl<'a, C, NC, A> UrlMapPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &UrlMap) -> UrlMapPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &UrlMap) -> UrlMapPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -12816,7 +12812,7 @@ impl<'a, C, NC, A> UrlMapPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> UrlMapPatchCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> UrlMapPatchCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -12826,7 +12822,7 @@ impl<'a, C, NC, A> UrlMapPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Name of the UrlMap resource to update. - pub fn url_map(mut self, new_value: &str) -> UrlMapPatchCall<'a, C, NC, A> { + pub fn url_map(mut self, new_value: &str) -> UrlMapPatchCall<'a, C, A> { self._url_map = new_value.to_string(); self } @@ -12837,7 +12833,7 @@ impl<'a, C, NC, A> UrlMapPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlMapPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlMapPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12858,7 +12854,7 @@ impl<'a, C, NC, A> UrlMapPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UrlMapPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UrlMapPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12875,7 +12871,7 @@ impl<'a, C, NC, A> UrlMapPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UrlMapPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UrlMapPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12919,10 +12915,10 @@ impl<'a, C, NC, A> UrlMapPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct UrlMapUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlMapUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: UrlMap, _project: String, _url_map: String, @@ -12931,9 +12927,9 @@ pub struct UrlMapUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UrlMapUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UrlMapUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> UrlMapUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UrlMapUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13073,7 +13069,7 @@ impl<'a, C, NC, A> UrlMapUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &UrlMap) -> UrlMapUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &UrlMap) -> UrlMapUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13083,7 +13079,7 @@ impl<'a, C, NC, A> UrlMapUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> UrlMapUpdateCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> UrlMapUpdateCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -13093,7 +13089,7 @@ impl<'a, C, NC, A> UrlMapUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Name of the UrlMap resource to update. - pub fn url_map(mut self, new_value: &str) -> UrlMapUpdateCall<'a, C, NC, A> { + pub fn url_map(mut self, new_value: &str) -> UrlMapUpdateCall<'a, C, A> { self._url_map = new_value.to_string(); self } @@ -13104,7 +13100,7 @@ impl<'a, C, NC, A> UrlMapUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlMapUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlMapUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13125,7 +13121,7 @@ impl<'a, C, NC, A> UrlMapUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UrlMapUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UrlMapUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13142,7 +13138,7 @@ impl<'a, C, NC, A> UrlMapUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UrlMapUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UrlMapUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13180,10 +13176,10 @@ impl<'a, C, NC, A> UrlMapUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct UrlMapDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlMapDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _url_map: String, _delegate: Option<&'a mut Delegate>, @@ -13191,9 +13187,9 @@ pub struct UrlMapDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UrlMapDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UrlMapDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> UrlMapDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UrlMapDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13326,7 +13322,7 @@ impl<'a, C, NC, A> UrlMapDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> UrlMapDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> UrlMapDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -13336,7 +13332,7 @@ impl<'a, C, NC, A> UrlMapDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Name of the UrlMap resource to delete. - pub fn url_map(mut self, new_value: &str) -> UrlMapDeleteCall<'a, C, NC, A> { + pub fn url_map(mut self, new_value: &str) -> UrlMapDeleteCall<'a, C, A> { self._url_map = new_value.to_string(); self } @@ -13347,7 +13343,7 @@ impl<'a, C, NC, A> UrlMapDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlMapDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlMapDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13368,7 +13364,7 @@ impl<'a, C, NC, A> UrlMapDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UrlMapDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UrlMapDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13385,7 +13381,7 @@ impl<'a, C, NC, A> UrlMapDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UrlMapDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UrlMapDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13429,10 +13425,10 @@ impl<'a, C, NC, A> UrlMapDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct GlobalAddresseInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GlobalAddresseInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: Address, _project: String, _delegate: Option<&'a mut Delegate>, @@ -13440,9 +13436,9 @@ pub struct GlobalAddresseInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GlobalAddresseInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GlobalAddresseInsertCall<'a, C, A> {} -impl<'a, C, NC, A> GlobalAddresseInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GlobalAddresseInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13581,7 +13577,7 @@ impl<'a, C, NC, A> GlobalAddresseInsertCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Address) -> GlobalAddresseInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Address) -> GlobalAddresseInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13591,7 +13587,7 @@ impl<'a, C, NC, A> GlobalAddresseInsertCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> GlobalAddresseInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> GlobalAddresseInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -13602,7 +13598,7 @@ impl<'a, C, NC, A> GlobalAddresseInsertCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalAddresseInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalAddresseInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13623,7 +13619,7 @@ impl<'a, C, NC, A> GlobalAddresseInsertCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GlobalAddresseInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GlobalAddresseInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13640,7 +13636,7 @@ impl<'a, C, NC, A> GlobalAddresseInsertCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GlobalAddresseInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GlobalAddresseInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13681,10 +13677,10 @@ impl<'a, C, NC, A> GlobalAddresseInsertCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct GlobalAddresseListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GlobalAddresseListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -13694,9 +13690,9 @@ pub struct GlobalAddresseListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GlobalAddresseListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GlobalAddresseListCall<'a, C, A> {} -impl<'a, C, NC, A> GlobalAddresseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GlobalAddresseListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13837,7 +13833,7 @@ impl<'a, C, NC, A> GlobalAddresseListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> GlobalAddresseListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> GlobalAddresseListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -13845,7 +13841,7 @@ impl<'a, C, NC, A> GlobalAddresseListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> GlobalAddresseListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> GlobalAddresseListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -13853,7 +13849,7 @@ impl<'a, C, NC, A> GlobalAddresseListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> GlobalAddresseListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> GlobalAddresseListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -13861,7 +13857,7 @@ impl<'a, C, NC, A> GlobalAddresseListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> GlobalAddresseListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> GlobalAddresseListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -13872,7 +13868,7 @@ impl<'a, C, NC, A> GlobalAddresseListCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalAddresseListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalAddresseListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13893,7 +13889,7 @@ impl<'a, C, NC, A> GlobalAddresseListCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GlobalAddresseListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GlobalAddresseListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13910,7 +13906,7 @@ impl<'a, C, NC, A> GlobalAddresseListCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GlobalAddresseListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GlobalAddresseListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13948,10 +13944,10 @@ impl<'a, C, NC, A> GlobalAddresseListCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct GlobalAddresseGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GlobalAddresseGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _address: String, _delegate: Option<&'a mut Delegate>, @@ -13959,9 +13955,9 @@ pub struct GlobalAddresseGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GlobalAddresseGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GlobalAddresseGetCall<'a, C, A> {} -impl<'a, C, NC, A> GlobalAddresseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GlobalAddresseGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14094,7 +14090,7 @@ impl<'a, C, NC, A> GlobalAddresseGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> GlobalAddresseGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> GlobalAddresseGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -14104,7 +14100,7 @@ impl<'a, C, NC, A> GlobalAddresseGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Name of the address resource to return. - pub fn address(mut self, new_value: &str) -> GlobalAddresseGetCall<'a, C, NC, A> { + pub fn address(mut self, new_value: &str) -> GlobalAddresseGetCall<'a, C, A> { self._address = new_value.to_string(); self } @@ -14115,7 +14111,7 @@ impl<'a, C, NC, A> GlobalAddresseGetCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalAddresseGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalAddresseGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14136,7 +14132,7 @@ impl<'a, C, NC, A> GlobalAddresseGetCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GlobalAddresseGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GlobalAddresseGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14153,7 +14149,7 @@ impl<'a, C, NC, A> GlobalAddresseGetCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GlobalAddresseGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GlobalAddresseGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14191,10 +14187,10 @@ impl<'a, C, NC, A> GlobalAddresseGetCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct GlobalAddresseDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GlobalAddresseDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _address: String, _delegate: Option<&'a mut Delegate>, @@ -14202,9 +14198,9 @@ pub struct GlobalAddresseDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GlobalAddresseDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GlobalAddresseDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> GlobalAddresseDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GlobalAddresseDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14337,7 +14333,7 @@ impl<'a, C, NC, A> GlobalAddresseDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> GlobalAddresseDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> GlobalAddresseDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -14347,7 +14343,7 @@ impl<'a, C, NC, A> GlobalAddresseDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Name of the address resource to delete. - pub fn address(mut self, new_value: &str) -> GlobalAddresseDeleteCall<'a, C, NC, A> { + pub fn address(mut self, new_value: &str) -> GlobalAddresseDeleteCall<'a, C, A> { self._address = new_value.to_string(); self } @@ -14358,7 +14354,7 @@ impl<'a, C, NC, A> GlobalAddresseDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalAddresseDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalAddresseDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14379,7 +14375,7 @@ impl<'a, C, NC, A> GlobalAddresseDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GlobalAddresseDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GlobalAddresseDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14396,7 +14392,7 @@ impl<'a, C, NC, A> GlobalAddresseDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GlobalAddresseDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GlobalAddresseDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14434,10 +14430,10 @@ impl<'a, C, NC, A> GlobalAddresseDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct SnapshotGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SnapshotGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _snapshot: String, _delegate: Option<&'a mut Delegate>, @@ -14445,9 +14441,9 @@ pub struct SnapshotGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SnapshotGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SnapshotGetCall<'a, C, A> {} -impl<'a, C, NC, A> SnapshotGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SnapshotGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14580,7 +14576,7 @@ impl<'a, C, NC, A> SnapshotGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> SnapshotGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> SnapshotGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -14590,7 +14586,7 @@ impl<'a, C, NC, A> SnapshotGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Name of the persistent disk snapshot resource to return. - pub fn snapshot(mut self, new_value: &str) -> SnapshotGetCall<'a, C, NC, A> { + pub fn snapshot(mut self, new_value: &str) -> SnapshotGetCall<'a, C, A> { self._snapshot = new_value.to_string(); self } @@ -14601,7 +14597,7 @@ impl<'a, C, NC, A> SnapshotGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SnapshotGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SnapshotGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14622,7 +14618,7 @@ impl<'a, C, NC, A> SnapshotGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SnapshotGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SnapshotGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14639,7 +14635,7 @@ impl<'a, C, NC, A> SnapshotGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SnapshotGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SnapshotGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14680,10 +14676,10 @@ impl<'a, C, NC, A> SnapshotGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct SnapshotListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SnapshotListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -14693,9 +14689,9 @@ pub struct SnapshotListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SnapshotListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SnapshotListCall<'a, C, A> {} -impl<'a, C, NC, A> SnapshotListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SnapshotListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14836,7 +14832,7 @@ impl<'a, C, NC, A> SnapshotListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> SnapshotListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> SnapshotListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -14844,7 +14840,7 @@ impl<'a, C, NC, A> SnapshotListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> SnapshotListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> SnapshotListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -14852,7 +14848,7 @@ impl<'a, C, NC, A> SnapshotListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> SnapshotListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> SnapshotListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -14860,7 +14856,7 @@ impl<'a, C, NC, A> SnapshotListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> SnapshotListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> SnapshotListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -14871,7 +14867,7 @@ impl<'a, C, NC, A> SnapshotListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SnapshotListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SnapshotListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14892,7 +14888,7 @@ impl<'a, C, NC, A> SnapshotListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SnapshotListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SnapshotListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14909,7 +14905,7 @@ impl<'a, C, NC, A> SnapshotListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SnapshotListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SnapshotListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14947,10 +14943,10 @@ impl<'a, C, NC, A> SnapshotListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct SnapshotDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SnapshotDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _snapshot: String, _delegate: Option<&'a mut Delegate>, @@ -14958,9 +14954,9 @@ pub struct SnapshotDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SnapshotDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SnapshotDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> SnapshotDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SnapshotDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15093,7 +15089,7 @@ impl<'a, C, NC, A> SnapshotDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> SnapshotDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> SnapshotDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -15103,7 +15099,7 @@ impl<'a, C, NC, A> SnapshotDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Name of the persistent disk snapshot resource to delete. - pub fn snapshot(mut self, new_value: &str) -> SnapshotDeleteCall<'a, C, NC, A> { + pub fn snapshot(mut self, new_value: &str) -> SnapshotDeleteCall<'a, C, A> { self._snapshot = new_value.to_string(); self } @@ -15114,7 +15110,7 @@ impl<'a, C, NC, A> SnapshotDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SnapshotDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SnapshotDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15135,7 +15131,7 @@ impl<'a, C, NC, A> SnapshotDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SnapshotDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SnapshotDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15152,7 +15148,7 @@ impl<'a, C, NC, A> SnapshotDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SnapshotDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SnapshotDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15190,10 +15186,10 @@ impl<'a, C, NC, A> SnapshotDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct DiskTypeGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DiskTypeGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _disk_type: String, @@ -15202,9 +15198,9 @@ pub struct DiskTypeGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DiskTypeGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DiskTypeGetCall<'a, C, A> {} -impl<'a, C, NC, A> DiskTypeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DiskTypeGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15338,7 +15334,7 @@ impl<'a, C, NC, A> DiskTypeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> DiskTypeGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> DiskTypeGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -15348,7 +15344,7 @@ impl<'a, C, NC, A> DiskTypeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> DiskTypeGetCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> DiskTypeGetCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -15358,7 +15354,7 @@ impl<'a, C, NC, A> DiskTypeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Name of the disk type resource to return. - pub fn disk_type(mut self, new_value: &str) -> DiskTypeGetCall<'a, C, NC, A> { + pub fn disk_type(mut self, new_value: &str) -> DiskTypeGetCall<'a, C, A> { self._disk_type = new_value.to_string(); self } @@ -15369,7 +15365,7 @@ impl<'a, C, NC, A> DiskTypeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DiskTypeGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DiskTypeGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15390,7 +15386,7 @@ impl<'a, C, NC, A> DiskTypeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DiskTypeGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DiskTypeGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15407,7 +15403,7 @@ impl<'a, C, NC, A> DiskTypeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DiskTypeGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DiskTypeGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15448,10 +15444,10 @@ impl<'a, C, NC, A> DiskTypeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct DiskTypeAggregatedListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DiskTypeAggregatedListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -15461,9 +15457,9 @@ pub struct DiskTypeAggregatedListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DiskTypeAggregatedListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DiskTypeAggregatedListCall<'a, C, A> {} -impl<'a, C, NC, A> DiskTypeAggregatedListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DiskTypeAggregatedListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15604,7 +15600,7 @@ impl<'a, C, NC, A> DiskTypeAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> DiskTypeAggregatedListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> DiskTypeAggregatedListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -15612,7 +15608,7 @@ impl<'a, C, NC, A> DiskTypeAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> DiskTypeAggregatedListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> DiskTypeAggregatedListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -15620,7 +15616,7 @@ impl<'a, C, NC, A> DiskTypeAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> DiskTypeAggregatedListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> DiskTypeAggregatedListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -15628,7 +15624,7 @@ impl<'a, C, NC, A> DiskTypeAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> DiskTypeAggregatedListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> DiskTypeAggregatedListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -15639,7 +15635,7 @@ impl<'a, C, NC, A> DiskTypeAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DiskTypeAggregatedListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DiskTypeAggregatedListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15660,7 +15656,7 @@ impl<'a, C, NC, A> DiskTypeAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DiskTypeAggregatedListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DiskTypeAggregatedListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15677,7 +15673,7 @@ impl<'a, C, NC, A> DiskTypeAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DiskTypeAggregatedListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DiskTypeAggregatedListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15718,10 +15714,10 @@ impl<'a, C, NC, A> DiskTypeAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct DiskTypeListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DiskTypeListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _page_token: Option, @@ -15732,9 +15728,9 @@ pub struct DiskTypeListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DiskTypeListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DiskTypeListCall<'a, C, A> {} -impl<'a, C, NC, A> DiskTypeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DiskTypeListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15876,7 +15872,7 @@ impl<'a, C, NC, A> DiskTypeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> DiskTypeListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> DiskTypeListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -15886,7 +15882,7 @@ impl<'a, C, NC, A> DiskTypeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> DiskTypeListCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> DiskTypeListCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -15894,7 +15890,7 @@ impl<'a, C, NC, A> DiskTypeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> DiskTypeListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> DiskTypeListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -15902,7 +15898,7 @@ impl<'a, C, NC, A> DiskTypeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> DiskTypeListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> DiskTypeListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -15910,7 +15906,7 @@ impl<'a, C, NC, A> DiskTypeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> DiskTypeListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> DiskTypeListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -15921,7 +15917,7 @@ impl<'a, C, NC, A> DiskTypeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DiskTypeListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DiskTypeListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15942,7 +15938,7 @@ impl<'a, C, NC, A> DiskTypeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DiskTypeListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DiskTypeListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15959,7 +15955,7 @@ impl<'a, C, NC, A> DiskTypeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DiskTypeListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DiskTypeListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15997,10 +15993,10 @@ impl<'a, C, NC, A> DiskTypeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct ZoneGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _delegate: Option<&'a mut Delegate>, @@ -16008,9 +16004,9 @@ pub struct ZoneGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ZoneGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ZoneGetCall<'a, C, A> {} -impl<'a, C, NC, A> ZoneGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ZoneGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16143,7 +16139,7 @@ impl<'a, C, NC, A> ZoneGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> ZoneGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ZoneGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -16153,7 +16149,7 @@ impl<'a, C, NC, A> ZoneGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// Name of the zone resource to return. - pub fn zone(mut self, new_value: &str) -> ZoneGetCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> ZoneGetCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -16164,7 +16160,7 @@ impl<'a, C, NC, A> ZoneGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16185,7 +16181,7 @@ impl<'a, C, NC, A> ZoneGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ZoneGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ZoneGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16202,7 +16198,7 @@ impl<'a, C, NC, A> ZoneGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ZoneGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ZoneGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16243,10 +16239,10 @@ impl<'a, C, NC, A> ZoneGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct ZoneListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -16256,9 +16252,9 @@ pub struct ZoneListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ZoneListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ZoneListCall<'a, C, A> {} -impl<'a, C, NC, A> ZoneListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ZoneListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16399,7 +16395,7 @@ impl<'a, C, NC, A> ZoneListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> ZoneListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ZoneListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -16407,7 +16403,7 @@ impl<'a, C, NC, A> ZoneListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> ZoneListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ZoneListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -16415,7 +16411,7 @@ impl<'a, C, NC, A> ZoneListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> ZoneListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> ZoneListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -16423,7 +16419,7 @@ impl<'a, C, NC, A> ZoneListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> ZoneListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> ZoneListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -16434,7 +16430,7 @@ impl<'a, C, NC, A> ZoneListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16455,7 +16451,7 @@ impl<'a, C, NC, A> ZoneListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ZoneListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ZoneListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16472,7 +16468,7 @@ impl<'a, C, NC, A> ZoneListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ZoneListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ZoneListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16516,10 +16512,10 @@ impl<'a, C, NC, A> ZoneListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct InstanceSetSchedulingCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceSetSchedulingCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: Scheduling, _project: String, _zone: String, @@ -16529,9 +16525,9 @@ pub struct InstanceSetSchedulingCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceSetSchedulingCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceSetSchedulingCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceSetSchedulingCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceSetSchedulingCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16672,7 +16668,7 @@ impl<'a, C, NC, A> InstanceSetSchedulingCall<'a, C, NC, A> where NC: hyper::net: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Scheduling) -> InstanceSetSchedulingCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Scheduling) -> InstanceSetSchedulingCall<'a, C, A> { self._request = new_value.clone(); self } @@ -16682,7 +16678,7 @@ impl<'a, C, NC, A> InstanceSetSchedulingCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> InstanceSetSchedulingCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceSetSchedulingCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -16692,7 +16688,7 @@ impl<'a, C, NC, A> InstanceSetSchedulingCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> InstanceSetSchedulingCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceSetSchedulingCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -16702,7 +16698,7 @@ impl<'a, C, NC, A> InstanceSetSchedulingCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Instance name. - pub fn instance(mut self, new_value: &str) -> InstanceSetSchedulingCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceSetSchedulingCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -16713,7 +16709,7 @@ impl<'a, C, NC, A> InstanceSetSchedulingCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceSetSchedulingCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceSetSchedulingCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16734,7 +16730,7 @@ impl<'a, C, NC, A> InstanceSetSchedulingCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceSetSchedulingCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceSetSchedulingCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16751,7 +16747,7 @@ impl<'a, C, NC, A> InstanceSetSchedulingCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceSetSchedulingCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceSetSchedulingCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16789,10 +16785,10 @@ impl<'a, C, NC, A> InstanceSetSchedulingCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct InstanceDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _instance: String, @@ -16801,9 +16797,9 @@ pub struct InstanceDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16937,7 +16933,7 @@ impl<'a, C, NC, A> InstanceDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> InstanceDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -16947,7 +16943,7 @@ impl<'a, C, NC, A> InstanceDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> InstanceDeleteCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceDeleteCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -16957,7 +16953,7 @@ impl<'a, C, NC, A> InstanceDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Name of the instance resource to delete. - pub fn instance(mut self, new_value: &str) -> InstanceDeleteCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceDeleteCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -16968,7 +16964,7 @@ impl<'a, C, NC, A> InstanceDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16989,7 +16985,7 @@ impl<'a, C, NC, A> InstanceDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17006,7 +17002,7 @@ impl<'a, C, NC, A> InstanceDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17044,10 +17040,10 @@ impl<'a, C, NC, A> InstanceDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct InstanceGetSerialPortOutputCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceGetSerialPortOutputCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _instance: String, @@ -17056,9 +17052,9 @@ pub struct InstanceGetSerialPortOutputCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceGetSerialPortOutputCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceGetSerialPortOutputCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceGetSerialPortOutputCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceGetSerialPortOutputCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17192,7 +17188,7 @@ impl<'a, C, NC, A> InstanceGetSerialPortOutputCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> InstanceGetSerialPortOutputCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceGetSerialPortOutputCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -17202,7 +17198,7 @@ impl<'a, C, NC, A> InstanceGetSerialPortOutputCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> InstanceGetSerialPortOutputCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceGetSerialPortOutputCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -17212,7 +17208,7 @@ impl<'a, C, NC, A> InstanceGetSerialPortOutputCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// Name of the instance scoping this request. - pub fn instance(mut self, new_value: &str) -> InstanceGetSerialPortOutputCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceGetSerialPortOutputCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -17223,7 +17219,7 @@ impl<'a, C, NC, A> InstanceGetSerialPortOutputCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGetSerialPortOutputCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGetSerialPortOutputCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17244,7 +17240,7 @@ impl<'a, C, NC, A> InstanceGetSerialPortOutputCall<'a, C, NC, A> where NC: hyper /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceGetSerialPortOutputCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceGetSerialPortOutputCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17261,7 +17257,7 @@ impl<'a, C, NC, A> InstanceGetSerialPortOutputCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceGetSerialPortOutputCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceGetSerialPortOutputCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17299,10 +17295,10 @@ impl<'a, C, NC, A> InstanceGetSerialPortOutputCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct InstanceSetDiskAutoDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceSetDiskAutoDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _instance: String, @@ -17313,9 +17309,9 @@ pub struct InstanceSetDiskAutoDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceSetDiskAutoDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceSetDiskAutoDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceSetDiskAutoDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceSetDiskAutoDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17451,7 +17447,7 @@ impl<'a, C, NC, A> InstanceSetDiskAutoDeleteCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> InstanceSetDiskAutoDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceSetDiskAutoDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -17461,7 +17457,7 @@ impl<'a, C, NC, A> InstanceSetDiskAutoDeleteCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> InstanceSetDiskAutoDeleteCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceSetDiskAutoDeleteCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -17471,7 +17467,7 @@ impl<'a, C, NC, A> InstanceSetDiskAutoDeleteCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The instance name. - pub fn instance(mut self, new_value: &str) -> InstanceSetDiskAutoDeleteCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceSetDiskAutoDeleteCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -17481,7 +17477,7 @@ impl<'a, C, NC, A> InstanceSetDiskAutoDeleteCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Whether to auto-delete the disk when the instance is deleted. - pub fn auto_delete(mut self, new_value: bool) -> InstanceSetDiskAutoDeleteCall<'a, C, NC, A> { + pub fn auto_delete(mut self, new_value: bool) -> InstanceSetDiskAutoDeleteCall<'a, C, A> { self._auto_delete = new_value; self } @@ -17491,7 +17487,7 @@ impl<'a, C, NC, A> InstanceSetDiskAutoDeleteCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The device name of the disk to modify. - pub fn device_name(mut self, new_value: &str) -> InstanceSetDiskAutoDeleteCall<'a, C, NC, A> { + pub fn device_name(mut self, new_value: &str) -> InstanceSetDiskAutoDeleteCall<'a, C, A> { self._device_name = new_value.to_string(); self } @@ -17502,7 +17498,7 @@ impl<'a, C, NC, A> InstanceSetDiskAutoDeleteCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceSetDiskAutoDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceSetDiskAutoDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17523,7 +17519,7 @@ impl<'a, C, NC, A> InstanceSetDiskAutoDeleteCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceSetDiskAutoDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceSetDiskAutoDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17540,7 +17536,7 @@ impl<'a, C, NC, A> InstanceSetDiskAutoDeleteCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceSetDiskAutoDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceSetDiskAutoDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17584,10 +17580,10 @@ impl<'a, C, NC, A> InstanceSetDiskAutoDeleteCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct InstanceAddAccessConfigCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceAddAccessConfigCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: AccessConfig, _project: String, _zone: String, @@ -17598,9 +17594,9 @@ pub struct InstanceAddAccessConfigCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceAddAccessConfigCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceAddAccessConfigCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceAddAccessConfigCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceAddAccessConfigCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17742,7 +17738,7 @@ impl<'a, C, NC, A> InstanceAddAccessConfigCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AccessConfig) -> InstanceAddAccessConfigCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AccessConfig) -> InstanceAddAccessConfigCall<'a, C, A> { self._request = new_value.clone(); self } @@ -17752,7 +17748,7 @@ impl<'a, C, NC, A> InstanceAddAccessConfigCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> InstanceAddAccessConfigCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceAddAccessConfigCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -17762,7 +17758,7 @@ impl<'a, C, NC, A> InstanceAddAccessConfigCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> InstanceAddAccessConfigCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceAddAccessConfigCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -17772,7 +17768,7 @@ impl<'a, C, NC, A> InstanceAddAccessConfigCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The instance name for this request. - pub fn instance(mut self, new_value: &str) -> InstanceAddAccessConfigCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceAddAccessConfigCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -17782,7 +17778,7 @@ impl<'a, C, NC, A> InstanceAddAccessConfigCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The name of the network interface to add to this instance. - pub fn network_interface(mut self, new_value: &str) -> InstanceAddAccessConfigCall<'a, C, NC, A> { + pub fn network_interface(mut self, new_value: &str) -> InstanceAddAccessConfigCall<'a, C, A> { self._network_interface = new_value.to_string(); self } @@ -17793,7 +17789,7 @@ impl<'a, C, NC, A> InstanceAddAccessConfigCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceAddAccessConfigCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceAddAccessConfigCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17814,7 +17810,7 @@ impl<'a, C, NC, A> InstanceAddAccessConfigCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceAddAccessConfigCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceAddAccessConfigCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17831,7 +17827,7 @@ impl<'a, C, NC, A> InstanceAddAccessConfigCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceAddAccessConfigCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceAddAccessConfigCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17869,10 +17865,10 @@ impl<'a, C, NC, A> InstanceAddAccessConfigCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct InstanceStartCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceStartCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _instance: String, @@ -17881,9 +17877,9 @@ pub struct InstanceStartCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceStartCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceStartCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceStartCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceStartCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18017,7 +18013,7 @@ impl<'a, C, NC, A> InstanceStartCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> InstanceStartCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceStartCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -18027,7 +18023,7 @@ impl<'a, C, NC, A> InstanceStartCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> InstanceStartCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceStartCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -18037,7 +18033,7 @@ impl<'a, C, NC, A> InstanceStartCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Name of the instance resource to start. - pub fn instance(mut self, new_value: &str) -> InstanceStartCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceStartCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -18048,7 +18044,7 @@ impl<'a, C, NC, A> InstanceStartCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceStartCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceStartCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18069,7 +18065,7 @@ impl<'a, C, NC, A> InstanceStartCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceStartCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceStartCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18086,7 +18082,7 @@ impl<'a, C, NC, A> InstanceStartCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceStartCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceStartCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18124,10 +18120,10 @@ impl<'a, C, NC, A> InstanceStartCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct InstanceGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _instance: String, @@ -18136,9 +18132,9 @@ pub struct InstanceGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceGetCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18272,7 +18268,7 @@ impl<'a, C, NC, A> InstanceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> InstanceGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -18282,7 +18278,7 @@ impl<'a, C, NC, A> InstanceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The name of the The name of the zone for this request.. - pub fn zone(mut self, new_value: &str) -> InstanceGetCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceGetCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -18292,7 +18288,7 @@ impl<'a, C, NC, A> InstanceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Name of the instance resource to return. - pub fn instance(mut self, new_value: &str) -> InstanceGetCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceGetCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -18303,7 +18299,7 @@ impl<'a, C, NC, A> InstanceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18324,7 +18320,7 @@ impl<'a, C, NC, A> InstanceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18341,7 +18337,7 @@ impl<'a, C, NC, A> InstanceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18385,10 +18381,10 @@ impl<'a, C, NC, A> InstanceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct InstanceSetTagCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceSetTagCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: Tags, _project: String, _zone: String, @@ -18398,9 +18394,9 @@ pub struct InstanceSetTagCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceSetTagCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceSetTagCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceSetTagCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceSetTagCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18541,7 +18537,7 @@ impl<'a, C, NC, A> InstanceSetTagCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Tags) -> InstanceSetTagCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Tags) -> InstanceSetTagCall<'a, C, A> { self._request = new_value.clone(); self } @@ -18551,7 +18547,7 @@ impl<'a, C, NC, A> InstanceSetTagCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> InstanceSetTagCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceSetTagCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -18561,7 +18557,7 @@ impl<'a, C, NC, A> InstanceSetTagCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> InstanceSetTagCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceSetTagCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -18571,7 +18567,7 @@ impl<'a, C, NC, A> InstanceSetTagCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Name of the instance scoping this request. - pub fn instance(mut self, new_value: &str) -> InstanceSetTagCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceSetTagCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -18582,7 +18578,7 @@ impl<'a, C, NC, A> InstanceSetTagCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceSetTagCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceSetTagCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18603,7 +18599,7 @@ impl<'a, C, NC, A> InstanceSetTagCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceSetTagCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceSetTagCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18620,7 +18616,7 @@ impl<'a, C, NC, A> InstanceSetTagCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceSetTagCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceSetTagCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18664,10 +18660,10 @@ impl<'a, C, NC, A> InstanceSetTagCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct InstanceSetMetadataCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceSetMetadataCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: Metadata, _project: String, _zone: String, @@ -18677,9 +18673,9 @@ pub struct InstanceSetMetadataCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceSetMetadataCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceSetMetadataCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceSetMetadataCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceSetMetadataCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18820,7 +18816,7 @@ impl<'a, C, NC, A> InstanceSetMetadataCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Metadata) -> InstanceSetMetadataCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Metadata) -> InstanceSetMetadataCall<'a, C, A> { self._request = new_value.clone(); self } @@ -18830,7 +18826,7 @@ impl<'a, C, NC, A> InstanceSetMetadataCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> InstanceSetMetadataCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceSetMetadataCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -18840,7 +18836,7 @@ impl<'a, C, NC, A> InstanceSetMetadataCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> InstanceSetMetadataCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceSetMetadataCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -18850,7 +18846,7 @@ impl<'a, C, NC, A> InstanceSetMetadataCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Name of the instance scoping this request. - pub fn instance(mut self, new_value: &str) -> InstanceSetMetadataCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceSetMetadataCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -18861,7 +18857,7 @@ impl<'a, C, NC, A> InstanceSetMetadataCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceSetMetadataCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceSetMetadataCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18882,7 +18878,7 @@ impl<'a, C, NC, A> InstanceSetMetadataCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceSetMetadataCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceSetMetadataCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18899,7 +18895,7 @@ impl<'a, C, NC, A> InstanceSetMetadataCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceSetMetadataCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceSetMetadataCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18937,10 +18933,10 @@ impl<'a, C, NC, A> InstanceSetMetadataCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct InstanceDetachDiskCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceDetachDiskCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _instance: String, @@ -18950,9 +18946,9 @@ pub struct InstanceDetachDiskCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceDetachDiskCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceDetachDiskCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceDetachDiskCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceDetachDiskCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19087,7 +19083,7 @@ impl<'a, C, NC, A> InstanceDetachDiskCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> InstanceDetachDiskCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceDetachDiskCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -19097,7 +19093,7 @@ impl<'a, C, NC, A> InstanceDetachDiskCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> InstanceDetachDiskCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceDetachDiskCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -19107,7 +19103,7 @@ impl<'a, C, NC, A> InstanceDetachDiskCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Instance name. - pub fn instance(mut self, new_value: &str) -> InstanceDetachDiskCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceDetachDiskCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -19117,7 +19113,7 @@ impl<'a, C, NC, A> InstanceDetachDiskCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Disk device name to detach. - pub fn device_name(mut self, new_value: &str) -> InstanceDetachDiskCall<'a, C, NC, A> { + pub fn device_name(mut self, new_value: &str) -> InstanceDetachDiskCall<'a, C, A> { self._device_name = new_value.to_string(); self } @@ -19128,7 +19124,7 @@ impl<'a, C, NC, A> InstanceDetachDiskCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceDetachDiskCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceDetachDiskCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19149,7 +19145,7 @@ impl<'a, C, NC, A> InstanceDetachDiskCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceDetachDiskCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceDetachDiskCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19166,7 +19162,7 @@ impl<'a, C, NC, A> InstanceDetachDiskCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceDetachDiskCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceDetachDiskCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19204,10 +19200,10 @@ impl<'a, C, NC, A> InstanceDetachDiskCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct InstanceStopCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceStopCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _instance: String, @@ -19216,9 +19212,9 @@ pub struct InstanceStopCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceStopCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceStopCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceStopCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceStopCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19352,7 +19348,7 @@ impl<'a, C, NC, A> InstanceStopCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> InstanceStopCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceStopCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -19362,7 +19358,7 @@ impl<'a, C, NC, A> InstanceStopCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> InstanceStopCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceStopCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -19372,7 +19368,7 @@ impl<'a, C, NC, A> InstanceStopCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Name of the instance resource to start. - pub fn instance(mut self, new_value: &str) -> InstanceStopCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceStopCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -19383,7 +19379,7 @@ impl<'a, C, NC, A> InstanceStopCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceStopCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceStopCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19404,7 +19400,7 @@ impl<'a, C, NC, A> InstanceStopCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceStopCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceStopCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19421,7 +19417,7 @@ impl<'a, C, NC, A> InstanceStopCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceStopCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceStopCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19465,10 +19461,10 @@ impl<'a, C, NC, A> InstanceStopCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct InstanceInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: Instance, _project: String, _zone: String, @@ -19477,9 +19473,9 @@ pub struct InstanceInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceInsertCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19619,7 +19615,7 @@ impl<'a, C, NC, A> InstanceInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Instance) -> InstanceInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Instance) -> InstanceInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -19629,7 +19625,7 @@ impl<'a, C, NC, A> InstanceInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> InstanceInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -19639,7 +19635,7 @@ impl<'a, C, NC, A> InstanceInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> InstanceInsertCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceInsertCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -19650,7 +19646,7 @@ impl<'a, C, NC, A> InstanceInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19671,7 +19667,7 @@ impl<'a, C, NC, A> InstanceInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19688,7 +19684,7 @@ impl<'a, C, NC, A> InstanceInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19726,10 +19722,10 @@ impl<'a, C, NC, A> InstanceInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct InstanceResetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceResetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _instance: String, @@ -19738,9 +19734,9 @@ pub struct InstanceResetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceResetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceResetCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceResetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceResetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19874,7 +19870,7 @@ impl<'a, C, NC, A> InstanceResetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> InstanceResetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceResetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -19884,7 +19880,7 @@ impl<'a, C, NC, A> InstanceResetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> InstanceResetCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceResetCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -19894,7 +19890,7 @@ impl<'a, C, NC, A> InstanceResetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Name of the instance scoping this request. - pub fn instance(mut self, new_value: &str) -> InstanceResetCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceResetCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -19905,7 +19901,7 @@ impl<'a, C, NC, A> InstanceResetCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceResetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceResetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19926,7 +19922,7 @@ impl<'a, C, NC, A> InstanceResetCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceResetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceResetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19943,7 +19939,7 @@ impl<'a, C, NC, A> InstanceResetCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceResetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceResetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19981,10 +19977,10 @@ impl<'a, C, NC, A> InstanceResetCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct InstanceDeleteAccessConfigCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceDeleteAccessConfigCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _instance: String, @@ -19995,9 +19991,9 @@ pub struct InstanceDeleteAccessConfigCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceDeleteAccessConfigCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceDeleteAccessConfigCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceDeleteAccessConfigCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceDeleteAccessConfigCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -20133,7 +20129,7 @@ impl<'a, C, NC, A> InstanceDeleteAccessConfigCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> InstanceDeleteAccessConfigCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceDeleteAccessConfigCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -20143,7 +20139,7 @@ impl<'a, C, NC, A> InstanceDeleteAccessConfigCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> InstanceDeleteAccessConfigCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceDeleteAccessConfigCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -20153,7 +20149,7 @@ impl<'a, C, NC, A> InstanceDeleteAccessConfigCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The instance name for this request. - pub fn instance(mut self, new_value: &str) -> InstanceDeleteAccessConfigCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceDeleteAccessConfigCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -20163,7 +20159,7 @@ impl<'a, C, NC, A> InstanceDeleteAccessConfigCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The name of the access config to delete. - pub fn access_config(mut self, new_value: &str) -> InstanceDeleteAccessConfigCall<'a, C, NC, A> { + pub fn access_config(mut self, new_value: &str) -> InstanceDeleteAccessConfigCall<'a, C, A> { self._access_config = new_value.to_string(); self } @@ -20173,7 +20169,7 @@ impl<'a, C, NC, A> InstanceDeleteAccessConfigCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The name of the network interface. - pub fn network_interface(mut self, new_value: &str) -> InstanceDeleteAccessConfigCall<'a, C, NC, A> { + pub fn network_interface(mut self, new_value: &str) -> InstanceDeleteAccessConfigCall<'a, C, A> { self._network_interface = new_value.to_string(); self } @@ -20184,7 +20180,7 @@ impl<'a, C, NC, A> InstanceDeleteAccessConfigCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceDeleteAccessConfigCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceDeleteAccessConfigCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -20205,7 +20201,7 @@ impl<'a, C, NC, A> InstanceDeleteAccessConfigCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceDeleteAccessConfigCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceDeleteAccessConfigCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -20222,7 +20218,7 @@ impl<'a, C, NC, A> InstanceDeleteAccessConfigCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceDeleteAccessConfigCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceDeleteAccessConfigCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -20266,10 +20262,10 @@ impl<'a, C, NC, A> InstanceDeleteAccessConfigCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct InstanceAttachDiskCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceAttachDiskCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: AttachedDisk, _project: String, _zone: String, @@ -20279,9 +20275,9 @@ pub struct InstanceAttachDiskCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceAttachDiskCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceAttachDiskCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceAttachDiskCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceAttachDiskCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -20422,7 +20418,7 @@ impl<'a, C, NC, A> InstanceAttachDiskCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AttachedDisk) -> InstanceAttachDiskCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AttachedDisk) -> InstanceAttachDiskCall<'a, C, A> { self._request = new_value.clone(); self } @@ -20432,7 +20428,7 @@ impl<'a, C, NC, A> InstanceAttachDiskCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> InstanceAttachDiskCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceAttachDiskCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -20442,7 +20438,7 @@ impl<'a, C, NC, A> InstanceAttachDiskCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> InstanceAttachDiskCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceAttachDiskCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -20452,7 +20448,7 @@ impl<'a, C, NC, A> InstanceAttachDiskCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Instance name. - pub fn instance(mut self, new_value: &str) -> InstanceAttachDiskCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceAttachDiskCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -20463,7 +20459,7 @@ impl<'a, C, NC, A> InstanceAttachDiskCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceAttachDiskCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceAttachDiskCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -20484,7 +20480,7 @@ impl<'a, C, NC, A> InstanceAttachDiskCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceAttachDiskCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceAttachDiskCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -20501,7 +20497,7 @@ impl<'a, C, NC, A> InstanceAttachDiskCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceAttachDiskCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceAttachDiskCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -20542,10 +20538,10 @@ impl<'a, C, NC, A> InstanceAttachDiskCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct InstanceListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _page_token: Option, @@ -20556,9 +20552,9 @@ pub struct InstanceListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceListCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -20700,7 +20696,7 @@ impl<'a, C, NC, A> InstanceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> InstanceListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -20710,7 +20706,7 @@ impl<'a, C, NC, A> InstanceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> InstanceListCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceListCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -20718,7 +20714,7 @@ impl<'a, C, NC, A> InstanceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> InstanceListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> InstanceListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -20726,7 +20722,7 @@ impl<'a, C, NC, A> InstanceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> InstanceListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> InstanceListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -20734,7 +20730,7 @@ impl<'a, C, NC, A> InstanceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> InstanceListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> InstanceListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -20745,7 +20741,7 @@ impl<'a, C, NC, A> InstanceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -20766,7 +20762,7 @@ impl<'a, C, NC, A> InstanceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -20783,7 +20779,7 @@ impl<'a, C, NC, A> InstanceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -20822,10 +20818,10 @@ impl<'a, C, NC, A> InstanceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct InstanceAggregatedListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceAggregatedListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -20835,9 +20831,9 @@ pub struct InstanceAggregatedListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceAggregatedListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceAggregatedListCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceAggregatedListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceAggregatedListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -20978,7 +20974,7 @@ impl<'a, C, NC, A> InstanceAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> InstanceAggregatedListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceAggregatedListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -20986,7 +20982,7 @@ impl<'a, C, NC, A> InstanceAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> InstanceAggregatedListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> InstanceAggregatedListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -20994,7 +20990,7 @@ impl<'a, C, NC, A> InstanceAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> InstanceAggregatedListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> InstanceAggregatedListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -21002,7 +20998,7 @@ impl<'a, C, NC, A> InstanceAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> InstanceAggregatedListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> InstanceAggregatedListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -21013,7 +21009,7 @@ impl<'a, C, NC, A> InstanceAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceAggregatedListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceAggregatedListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -21034,7 +21030,7 @@ impl<'a, C, NC, A> InstanceAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceAggregatedListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceAggregatedListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -21051,7 +21047,7 @@ impl<'a, C, NC, A> InstanceAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceAggregatedListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceAggregatedListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -21095,10 +21091,10 @@ impl<'a, C, NC, A> InstanceAggregatedListCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct BackendServiceGetHealthCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BackendServiceGetHealthCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: ResourceGroupReference, _project: String, _backend_service: String, @@ -21107,9 +21103,9 @@ pub struct BackendServiceGetHealthCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BackendServiceGetHealthCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BackendServiceGetHealthCall<'a, C, A> {} -impl<'a, C, NC, A> BackendServiceGetHealthCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BackendServiceGetHealthCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -21249,7 +21245,7 @@ impl<'a, C, NC, A> BackendServiceGetHealthCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ResourceGroupReference) -> BackendServiceGetHealthCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ResourceGroupReference) -> BackendServiceGetHealthCall<'a, C, A> { self._request = new_value.clone(); self } @@ -21258,7 +21254,7 @@ impl<'a, C, NC, A> BackendServiceGetHealthCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn project(mut self, new_value: &str) -> BackendServiceGetHealthCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> BackendServiceGetHealthCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -21268,7 +21264,7 @@ impl<'a, C, NC, A> BackendServiceGetHealthCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Name of the BackendService resource to which the queried instance belongs. - pub fn backend_service(mut self, new_value: &str) -> BackendServiceGetHealthCall<'a, C, NC, A> { + pub fn backend_service(mut self, new_value: &str) -> BackendServiceGetHealthCall<'a, C, A> { self._backend_service = new_value.to_string(); self } @@ -21279,7 +21275,7 @@ impl<'a, C, NC, A> BackendServiceGetHealthCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BackendServiceGetHealthCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BackendServiceGetHealthCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -21300,7 +21296,7 @@ impl<'a, C, NC, A> BackendServiceGetHealthCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BackendServiceGetHealthCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BackendServiceGetHealthCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -21317,7 +21313,7 @@ impl<'a, C, NC, A> BackendServiceGetHealthCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BackendServiceGetHealthCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BackendServiceGetHealthCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -21355,10 +21351,10 @@ impl<'a, C, NC, A> BackendServiceGetHealthCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct BackendServiceDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BackendServiceDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _backend_service: String, _delegate: Option<&'a mut Delegate>, @@ -21366,9 +21362,9 @@ pub struct BackendServiceDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BackendServiceDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BackendServiceDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> BackendServiceDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BackendServiceDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -21501,7 +21497,7 @@ impl<'a, C, NC, A> BackendServiceDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> BackendServiceDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> BackendServiceDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -21511,7 +21507,7 @@ impl<'a, C, NC, A> BackendServiceDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Name of the BackendService resource to delete. - pub fn backend_service(mut self, new_value: &str) -> BackendServiceDeleteCall<'a, C, NC, A> { + pub fn backend_service(mut self, new_value: &str) -> BackendServiceDeleteCall<'a, C, A> { self._backend_service = new_value.to_string(); self } @@ -21522,7 +21518,7 @@ impl<'a, C, NC, A> BackendServiceDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BackendServiceDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BackendServiceDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -21543,7 +21539,7 @@ impl<'a, C, NC, A> BackendServiceDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BackendServiceDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BackendServiceDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -21560,7 +21556,7 @@ impl<'a, C, NC, A> BackendServiceDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BackendServiceDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BackendServiceDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -21598,10 +21594,10 @@ impl<'a, C, NC, A> BackendServiceDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct BackendServiceGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BackendServiceGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _backend_service: String, _delegate: Option<&'a mut Delegate>, @@ -21609,9 +21605,9 @@ pub struct BackendServiceGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BackendServiceGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BackendServiceGetCall<'a, C, A> {} -impl<'a, C, NC, A> BackendServiceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BackendServiceGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -21744,7 +21740,7 @@ impl<'a, C, NC, A> BackendServiceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> BackendServiceGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> BackendServiceGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -21754,7 +21750,7 @@ impl<'a, C, NC, A> BackendServiceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Name of the BackendService resource to return. - pub fn backend_service(mut self, new_value: &str) -> BackendServiceGetCall<'a, C, NC, A> { + pub fn backend_service(mut self, new_value: &str) -> BackendServiceGetCall<'a, C, A> { self._backend_service = new_value.to_string(); self } @@ -21765,7 +21761,7 @@ impl<'a, C, NC, A> BackendServiceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BackendServiceGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BackendServiceGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -21786,7 +21782,7 @@ impl<'a, C, NC, A> BackendServiceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BackendServiceGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BackendServiceGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -21803,7 +21799,7 @@ impl<'a, C, NC, A> BackendServiceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BackendServiceGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BackendServiceGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -21847,10 +21843,10 @@ impl<'a, C, NC, A> BackendServiceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct BackendServiceUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BackendServiceUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: BackendService, _project: String, _backend_service: String, @@ -21859,9 +21855,9 @@ pub struct BackendServiceUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BackendServiceUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BackendServiceUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> BackendServiceUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BackendServiceUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -22001,7 +21997,7 @@ impl<'a, C, NC, A> BackendServiceUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &BackendService) -> BackendServiceUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &BackendService) -> BackendServiceUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -22011,7 +22007,7 @@ impl<'a, C, NC, A> BackendServiceUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> BackendServiceUpdateCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> BackendServiceUpdateCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -22021,7 +22017,7 @@ impl<'a, C, NC, A> BackendServiceUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Name of the BackendService resource to update. - pub fn backend_service(mut self, new_value: &str) -> BackendServiceUpdateCall<'a, C, NC, A> { + pub fn backend_service(mut self, new_value: &str) -> BackendServiceUpdateCall<'a, C, A> { self._backend_service = new_value.to_string(); self } @@ -22032,7 +22028,7 @@ impl<'a, C, NC, A> BackendServiceUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BackendServiceUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BackendServiceUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -22053,7 +22049,7 @@ impl<'a, C, NC, A> BackendServiceUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BackendServiceUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BackendServiceUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -22070,7 +22066,7 @@ impl<'a, C, NC, A> BackendServiceUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BackendServiceUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BackendServiceUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -22111,10 +22107,10 @@ impl<'a, C, NC, A> BackendServiceUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct BackendServiceListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BackendServiceListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -22124,9 +22120,9 @@ pub struct BackendServiceListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BackendServiceListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BackendServiceListCall<'a, C, A> {} -impl<'a, C, NC, A> BackendServiceListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BackendServiceListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -22267,7 +22263,7 @@ impl<'a, C, NC, A> BackendServiceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> BackendServiceListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> BackendServiceListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -22275,7 +22271,7 @@ impl<'a, C, NC, A> BackendServiceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> BackendServiceListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> BackendServiceListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -22283,7 +22279,7 @@ impl<'a, C, NC, A> BackendServiceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> BackendServiceListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> BackendServiceListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -22291,7 +22287,7 @@ impl<'a, C, NC, A> BackendServiceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> BackendServiceListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> BackendServiceListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -22302,7 +22298,7 @@ impl<'a, C, NC, A> BackendServiceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BackendServiceListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BackendServiceListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -22323,7 +22319,7 @@ impl<'a, C, NC, A> BackendServiceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BackendServiceListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BackendServiceListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -22340,7 +22336,7 @@ impl<'a, C, NC, A> BackendServiceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BackendServiceListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BackendServiceListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -22384,10 +22380,10 @@ impl<'a, C, NC, A> BackendServiceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct BackendServicePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BackendServicePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: BackendService, _project: String, _backend_service: String, @@ -22396,9 +22392,9 @@ pub struct BackendServicePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BackendServicePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BackendServicePatchCall<'a, C, A> {} -impl<'a, C, NC, A> BackendServicePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BackendServicePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -22538,7 +22534,7 @@ impl<'a, C, NC, A> BackendServicePatchCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &BackendService) -> BackendServicePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &BackendService) -> BackendServicePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -22548,7 +22544,7 @@ impl<'a, C, NC, A> BackendServicePatchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> BackendServicePatchCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> BackendServicePatchCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -22558,7 +22554,7 @@ impl<'a, C, NC, A> BackendServicePatchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Name of the BackendService resource to update. - pub fn backend_service(mut self, new_value: &str) -> BackendServicePatchCall<'a, C, NC, A> { + pub fn backend_service(mut self, new_value: &str) -> BackendServicePatchCall<'a, C, A> { self._backend_service = new_value.to_string(); self } @@ -22569,7 +22565,7 @@ impl<'a, C, NC, A> BackendServicePatchCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BackendServicePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BackendServicePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -22590,7 +22586,7 @@ impl<'a, C, NC, A> BackendServicePatchCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BackendServicePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BackendServicePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -22607,7 +22603,7 @@ impl<'a, C, NC, A> BackendServicePatchCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BackendServicePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BackendServicePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -22651,10 +22647,10 @@ impl<'a, C, NC, A> BackendServicePatchCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct BackendServiceInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BackendServiceInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: BackendService, _project: String, _delegate: Option<&'a mut Delegate>, @@ -22662,9 +22658,9 @@ pub struct BackendServiceInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BackendServiceInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BackendServiceInsertCall<'a, C, A> {} -impl<'a, C, NC, A> BackendServiceInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BackendServiceInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -22803,7 +22799,7 @@ impl<'a, C, NC, A> BackendServiceInsertCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &BackendService) -> BackendServiceInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &BackendService) -> BackendServiceInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -22813,7 +22809,7 @@ impl<'a, C, NC, A> BackendServiceInsertCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> BackendServiceInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> BackendServiceInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -22824,7 +22820,7 @@ impl<'a, C, NC, A> BackendServiceInsertCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BackendServiceInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BackendServiceInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -22845,7 +22841,7 @@ impl<'a, C, NC, A> BackendServiceInsertCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BackendServiceInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BackendServiceInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -22862,7 +22858,7 @@ impl<'a, C, NC, A> BackendServiceInsertCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BackendServiceInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BackendServiceInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -22900,10 +22896,10 @@ impl<'a, C, NC, A> BackendServiceInsertCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct LicenseGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LicenseGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _license: String, _delegate: Option<&'a mut Delegate>, @@ -22911,9 +22907,9 @@ pub struct LicenseGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LicenseGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LicenseGetCall<'a, C, A> {} -impl<'a, C, NC, A> LicenseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LicenseGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -23046,7 +23042,7 @@ impl<'a, C, NC, A> LicenseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> LicenseGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> LicenseGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -23056,7 +23052,7 @@ impl<'a, C, NC, A> LicenseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Name of the license resource to return. - pub fn license(mut self, new_value: &str) -> LicenseGetCall<'a, C, NC, A> { + pub fn license(mut self, new_value: &str) -> LicenseGetCall<'a, C, A> { self._license = new_value.to_string(); self } @@ -23067,7 +23063,7 @@ impl<'a, C, NC, A> LicenseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LicenseGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LicenseGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -23088,7 +23084,7 @@ impl<'a, C, NC, A> LicenseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LicenseGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LicenseGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -23105,7 +23101,7 @@ impl<'a, C, NC, A> LicenseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LicenseGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LicenseGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -23149,10 +23145,10 @@ impl<'a, C, NC, A> LicenseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct NetworkInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct NetworkInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: Network, _project: String, _delegate: Option<&'a mut Delegate>, @@ -23160,9 +23156,9 @@ pub struct NetworkInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for NetworkInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for NetworkInsertCall<'a, C, A> {} -impl<'a, C, NC, A> NetworkInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> NetworkInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -23301,7 +23297,7 @@ impl<'a, C, NC, A> NetworkInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Network) -> NetworkInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Network) -> NetworkInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -23311,7 +23307,7 @@ impl<'a, C, NC, A> NetworkInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> NetworkInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> NetworkInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -23322,7 +23318,7 @@ impl<'a, C, NC, A> NetworkInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> NetworkInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> NetworkInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -23343,7 +23339,7 @@ impl<'a, C, NC, A> NetworkInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> NetworkInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> NetworkInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -23360,7 +23356,7 @@ impl<'a, C, NC, A> NetworkInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> NetworkInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> NetworkInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -23401,10 +23397,10 @@ impl<'a, C, NC, A> NetworkInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct NetworkListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct NetworkListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -23414,9 +23410,9 @@ pub struct NetworkListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for NetworkListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for NetworkListCall<'a, C, A> {} -impl<'a, C, NC, A> NetworkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> NetworkListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -23557,7 +23553,7 @@ impl<'a, C, NC, A> NetworkListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> NetworkListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> NetworkListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -23565,7 +23561,7 @@ impl<'a, C, NC, A> NetworkListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> NetworkListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> NetworkListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -23573,7 +23569,7 @@ impl<'a, C, NC, A> NetworkListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> NetworkListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> NetworkListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -23581,7 +23577,7 @@ impl<'a, C, NC, A> NetworkListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> NetworkListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> NetworkListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -23592,7 +23588,7 @@ impl<'a, C, NC, A> NetworkListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> NetworkListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> NetworkListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -23613,7 +23609,7 @@ impl<'a, C, NC, A> NetworkListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> NetworkListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> NetworkListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -23630,7 +23626,7 @@ impl<'a, C, NC, A> NetworkListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> NetworkListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> NetworkListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -23668,10 +23664,10 @@ impl<'a, C, NC, A> NetworkListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct NetworkDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct NetworkDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _network: String, _delegate: Option<&'a mut Delegate>, @@ -23679,9 +23675,9 @@ pub struct NetworkDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for NetworkDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for NetworkDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> NetworkDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> NetworkDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -23814,7 +23810,7 @@ impl<'a, C, NC, A> NetworkDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> NetworkDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> NetworkDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -23824,7 +23820,7 @@ impl<'a, C, NC, A> NetworkDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Name of the network resource to delete. - pub fn network(mut self, new_value: &str) -> NetworkDeleteCall<'a, C, NC, A> { + pub fn network(mut self, new_value: &str) -> NetworkDeleteCall<'a, C, A> { self._network = new_value.to_string(); self } @@ -23835,7 +23831,7 @@ impl<'a, C, NC, A> NetworkDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> NetworkDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> NetworkDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -23856,7 +23852,7 @@ impl<'a, C, NC, A> NetworkDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> NetworkDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> NetworkDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -23873,7 +23869,7 @@ impl<'a, C, NC, A> NetworkDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> NetworkDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> NetworkDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -23911,10 +23907,10 @@ impl<'a, C, NC, A> NetworkDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct NetworkGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct NetworkGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _network: String, _delegate: Option<&'a mut Delegate>, @@ -23922,9 +23918,9 @@ pub struct NetworkGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for NetworkGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for NetworkGetCall<'a, C, A> {} -impl<'a, C, NC, A> NetworkGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> NetworkGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -24057,7 +24053,7 @@ impl<'a, C, NC, A> NetworkGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> NetworkGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> NetworkGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -24067,7 +24063,7 @@ impl<'a, C, NC, A> NetworkGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Name of the network resource to return. - pub fn network(mut self, new_value: &str) -> NetworkGetCall<'a, C, NC, A> { + pub fn network(mut self, new_value: &str) -> NetworkGetCall<'a, C, A> { self._network = new_value.to_string(); self } @@ -24078,7 +24074,7 @@ impl<'a, C, NC, A> NetworkGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> NetworkGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> NetworkGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -24099,7 +24095,7 @@ impl<'a, C, NC, A> NetworkGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> NetworkGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> NetworkGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -24116,7 +24112,7 @@ impl<'a, C, NC, A> NetworkGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> NetworkGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> NetworkGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -24157,10 +24153,10 @@ impl<'a, C, NC, A> NetworkGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct GlobalOperationListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GlobalOperationListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -24170,9 +24166,9 @@ pub struct GlobalOperationListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GlobalOperationListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GlobalOperationListCall<'a, C, A> {} -impl<'a, C, NC, A> GlobalOperationListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GlobalOperationListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -24313,7 +24309,7 @@ impl<'a, C, NC, A> GlobalOperationListCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> GlobalOperationListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> GlobalOperationListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -24321,7 +24317,7 @@ impl<'a, C, NC, A> GlobalOperationListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> GlobalOperationListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> GlobalOperationListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -24329,7 +24325,7 @@ impl<'a, C, NC, A> GlobalOperationListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> GlobalOperationListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> GlobalOperationListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -24337,7 +24333,7 @@ impl<'a, C, NC, A> GlobalOperationListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> GlobalOperationListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> GlobalOperationListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -24348,7 +24344,7 @@ impl<'a, C, NC, A> GlobalOperationListCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalOperationListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalOperationListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -24369,7 +24365,7 @@ impl<'a, C, NC, A> GlobalOperationListCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GlobalOperationListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GlobalOperationListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -24386,7 +24382,7 @@ impl<'a, C, NC, A> GlobalOperationListCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GlobalOperationListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GlobalOperationListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -24424,10 +24420,10 @@ impl<'a, C, NC, A> GlobalOperationListCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct GlobalOperationGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GlobalOperationGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _operation: String, _delegate: Option<&'a mut Delegate>, @@ -24435,9 +24431,9 @@ pub struct GlobalOperationGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GlobalOperationGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GlobalOperationGetCall<'a, C, A> {} -impl<'a, C, NC, A> GlobalOperationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GlobalOperationGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -24570,7 +24566,7 @@ impl<'a, C, NC, A> GlobalOperationGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> GlobalOperationGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> GlobalOperationGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -24580,7 +24576,7 @@ impl<'a, C, NC, A> GlobalOperationGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Name of the operation resource to return. - pub fn operation(mut self, new_value: &str) -> GlobalOperationGetCall<'a, C, NC, A> { + pub fn operation(mut self, new_value: &str) -> GlobalOperationGetCall<'a, C, A> { self._operation = new_value.to_string(); self } @@ -24591,7 +24587,7 @@ impl<'a, C, NC, A> GlobalOperationGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalOperationGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalOperationGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -24612,7 +24608,7 @@ impl<'a, C, NC, A> GlobalOperationGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GlobalOperationGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GlobalOperationGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -24629,7 +24625,7 @@ impl<'a, C, NC, A> GlobalOperationGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GlobalOperationGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GlobalOperationGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -24667,10 +24663,10 @@ impl<'a, C, NC, A> GlobalOperationGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct GlobalOperationDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GlobalOperationDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _operation: String, _delegate: Option<&'a mut Delegate>, @@ -24678,9 +24674,9 @@ pub struct GlobalOperationDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GlobalOperationDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GlobalOperationDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> GlobalOperationDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GlobalOperationDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -24802,7 +24798,7 @@ impl<'a, C, NC, A> GlobalOperationDeleteCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> GlobalOperationDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> GlobalOperationDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -24812,7 +24808,7 @@ impl<'a, C, NC, A> GlobalOperationDeleteCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Name of the operation resource to delete. - pub fn operation(mut self, new_value: &str) -> GlobalOperationDeleteCall<'a, C, NC, A> { + pub fn operation(mut self, new_value: &str) -> GlobalOperationDeleteCall<'a, C, A> { self._operation = new_value.to_string(); self } @@ -24823,7 +24819,7 @@ impl<'a, C, NC, A> GlobalOperationDeleteCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalOperationDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalOperationDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -24844,7 +24840,7 @@ impl<'a, C, NC, A> GlobalOperationDeleteCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GlobalOperationDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GlobalOperationDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -24861,7 +24857,7 @@ impl<'a, C, NC, A> GlobalOperationDeleteCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GlobalOperationDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GlobalOperationDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -24902,10 +24898,10 @@ impl<'a, C, NC, A> GlobalOperationDeleteCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct GlobalOperationAggregatedListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GlobalOperationAggregatedListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -24915,9 +24911,9 @@ pub struct GlobalOperationAggregatedListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GlobalOperationAggregatedListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GlobalOperationAggregatedListCall<'a, C, A> {} -impl<'a, C, NC, A> GlobalOperationAggregatedListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GlobalOperationAggregatedListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -25058,7 +25054,7 @@ impl<'a, C, NC, A> GlobalOperationAggregatedListCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> GlobalOperationAggregatedListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> GlobalOperationAggregatedListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -25066,7 +25062,7 @@ impl<'a, C, NC, A> GlobalOperationAggregatedListCall<'a, C, NC, A> where NC: hyp /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> GlobalOperationAggregatedListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> GlobalOperationAggregatedListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -25074,7 +25070,7 @@ impl<'a, C, NC, A> GlobalOperationAggregatedListCall<'a, C, NC, A> where NC: hyp /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> GlobalOperationAggregatedListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> GlobalOperationAggregatedListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -25082,7 +25078,7 @@ impl<'a, C, NC, A> GlobalOperationAggregatedListCall<'a, C, NC, A> where NC: hyp /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> GlobalOperationAggregatedListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> GlobalOperationAggregatedListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -25093,7 +25089,7 @@ impl<'a, C, NC, A> GlobalOperationAggregatedListCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalOperationAggregatedListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalOperationAggregatedListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -25114,7 +25110,7 @@ impl<'a, C, NC, A> GlobalOperationAggregatedListCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GlobalOperationAggregatedListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GlobalOperationAggregatedListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -25131,7 +25127,7 @@ impl<'a, C, NC, A> GlobalOperationAggregatedListCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GlobalOperationAggregatedListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GlobalOperationAggregatedListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -25172,10 +25168,10 @@ impl<'a, C, NC, A> GlobalOperationAggregatedListCall<'a, C, NC, A> where NC: hyp /// .doit(); /// # } /// ``` -pub struct RegionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RegionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -25185,9 +25181,9 @@ pub struct RegionListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RegionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RegionListCall<'a, C, A> {} -impl<'a, C, NC, A> RegionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RegionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -25328,7 +25324,7 @@ impl<'a, C, NC, A> RegionListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> RegionListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> RegionListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -25336,7 +25332,7 @@ impl<'a, C, NC, A> RegionListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> RegionListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> RegionListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -25344,7 +25340,7 @@ impl<'a, C, NC, A> RegionListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> RegionListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> RegionListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -25352,7 +25348,7 @@ impl<'a, C, NC, A> RegionListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> RegionListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> RegionListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -25363,7 +25359,7 @@ impl<'a, C, NC, A> RegionListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RegionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RegionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -25384,7 +25380,7 @@ impl<'a, C, NC, A> RegionListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RegionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RegionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -25401,7 +25397,7 @@ impl<'a, C, NC, A> RegionListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RegionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RegionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -25439,10 +25435,10 @@ impl<'a, C, NC, A> RegionListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct RegionGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RegionGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _region: String, _delegate: Option<&'a mut Delegate>, @@ -25450,9 +25446,9 @@ pub struct RegionGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RegionGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RegionGetCall<'a, C, A> {} -impl<'a, C, NC, A> RegionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RegionGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -25585,7 +25581,7 @@ impl<'a, C, NC, A> RegionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> RegionGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> RegionGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -25595,7 +25591,7 @@ impl<'a, C, NC, A> RegionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Name of the region resource to return. - pub fn region(mut self, new_value: &str) -> RegionGetCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> RegionGetCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -25606,7 +25602,7 @@ impl<'a, C, NC, A> RegionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RegionGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RegionGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -25627,7 +25623,7 @@ impl<'a, C, NC, A> RegionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RegionGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RegionGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -25644,7 +25640,7 @@ impl<'a, C, NC, A> RegionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RegionGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RegionGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -25685,10 +25681,10 @@ impl<'a, C, NC, A> RegionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct ForwardingRuleAggregatedListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ForwardingRuleAggregatedListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -25698,9 +25694,9 @@ pub struct ForwardingRuleAggregatedListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ForwardingRuleAggregatedListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ForwardingRuleAggregatedListCall<'a, C, A> {} -impl<'a, C, NC, A> ForwardingRuleAggregatedListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ForwardingRuleAggregatedListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -25841,7 +25837,7 @@ impl<'a, C, NC, A> ForwardingRuleAggregatedListCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> ForwardingRuleAggregatedListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ForwardingRuleAggregatedListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -25849,7 +25845,7 @@ impl<'a, C, NC, A> ForwardingRuleAggregatedListCall<'a, C, NC, A> where NC: hype /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> ForwardingRuleAggregatedListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ForwardingRuleAggregatedListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -25857,7 +25853,7 @@ impl<'a, C, NC, A> ForwardingRuleAggregatedListCall<'a, C, NC, A> where NC: hype /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> ForwardingRuleAggregatedListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> ForwardingRuleAggregatedListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -25865,7 +25861,7 @@ impl<'a, C, NC, A> ForwardingRuleAggregatedListCall<'a, C, NC, A> where NC: hype /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> ForwardingRuleAggregatedListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> ForwardingRuleAggregatedListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -25876,7 +25872,7 @@ impl<'a, C, NC, A> ForwardingRuleAggregatedListCall<'a, C, NC, A> where NC: hype /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ForwardingRuleAggregatedListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ForwardingRuleAggregatedListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -25897,7 +25893,7 @@ impl<'a, C, NC, A> ForwardingRuleAggregatedListCall<'a, C, NC, A> where NC: hype /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ForwardingRuleAggregatedListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ForwardingRuleAggregatedListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -25914,7 +25910,7 @@ impl<'a, C, NC, A> ForwardingRuleAggregatedListCall<'a, C, NC, A> where NC: hype /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ForwardingRuleAggregatedListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ForwardingRuleAggregatedListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -25958,10 +25954,10 @@ impl<'a, C, NC, A> ForwardingRuleAggregatedListCall<'a, C, NC, A> where NC: hype /// .doit(); /// # } /// ``` -pub struct ForwardingRuleInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ForwardingRuleInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: ForwardingRule, _project: String, _region: String, @@ -25970,9 +25966,9 @@ pub struct ForwardingRuleInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ForwardingRuleInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ForwardingRuleInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ForwardingRuleInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ForwardingRuleInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -26112,7 +26108,7 @@ impl<'a, C, NC, A> ForwardingRuleInsertCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ForwardingRule) -> ForwardingRuleInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ForwardingRule) -> ForwardingRuleInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -26122,7 +26118,7 @@ impl<'a, C, NC, A> ForwardingRuleInsertCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> ForwardingRuleInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ForwardingRuleInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -26132,7 +26128,7 @@ impl<'a, C, NC, A> ForwardingRuleInsertCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Name of the region scoping this request. - pub fn region(mut self, new_value: &str) -> ForwardingRuleInsertCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> ForwardingRuleInsertCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -26143,7 +26139,7 @@ impl<'a, C, NC, A> ForwardingRuleInsertCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ForwardingRuleInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ForwardingRuleInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -26164,7 +26160,7 @@ impl<'a, C, NC, A> ForwardingRuleInsertCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ForwardingRuleInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ForwardingRuleInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -26181,7 +26177,7 @@ impl<'a, C, NC, A> ForwardingRuleInsertCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ForwardingRuleInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ForwardingRuleInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -26225,10 +26221,10 @@ impl<'a, C, NC, A> ForwardingRuleInsertCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct ForwardingRuleSetTargetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ForwardingRuleSetTargetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: TargetReference, _project: String, _region: String, @@ -26238,9 +26234,9 @@ pub struct ForwardingRuleSetTargetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ForwardingRuleSetTargetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ForwardingRuleSetTargetCall<'a, C, A> {} -impl<'a, C, NC, A> ForwardingRuleSetTargetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ForwardingRuleSetTargetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -26381,7 +26377,7 @@ impl<'a, C, NC, A> ForwardingRuleSetTargetCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &TargetReference) -> ForwardingRuleSetTargetCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &TargetReference) -> ForwardingRuleSetTargetCall<'a, C, A> { self._request = new_value.clone(); self } @@ -26391,7 +26387,7 @@ impl<'a, C, NC, A> ForwardingRuleSetTargetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> ForwardingRuleSetTargetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ForwardingRuleSetTargetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -26401,7 +26397,7 @@ impl<'a, C, NC, A> ForwardingRuleSetTargetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Name of the region scoping this request. - pub fn region(mut self, new_value: &str) -> ForwardingRuleSetTargetCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> ForwardingRuleSetTargetCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -26411,7 +26407,7 @@ impl<'a, C, NC, A> ForwardingRuleSetTargetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Name of the ForwardingRule resource in which target is to be set. - pub fn forwarding_rule(mut self, new_value: &str) -> ForwardingRuleSetTargetCall<'a, C, NC, A> { + pub fn forwarding_rule(mut self, new_value: &str) -> ForwardingRuleSetTargetCall<'a, C, A> { self._forwarding_rule = new_value.to_string(); self } @@ -26422,7 +26418,7 @@ impl<'a, C, NC, A> ForwardingRuleSetTargetCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ForwardingRuleSetTargetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ForwardingRuleSetTargetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -26443,7 +26439,7 @@ impl<'a, C, NC, A> ForwardingRuleSetTargetCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ForwardingRuleSetTargetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ForwardingRuleSetTargetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -26460,7 +26456,7 @@ impl<'a, C, NC, A> ForwardingRuleSetTargetCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ForwardingRuleSetTargetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ForwardingRuleSetTargetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -26498,10 +26494,10 @@ impl<'a, C, NC, A> ForwardingRuleSetTargetCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct ForwardingRuleGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ForwardingRuleGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _region: String, _forwarding_rule: String, @@ -26510,9 +26506,9 @@ pub struct ForwardingRuleGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ForwardingRuleGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ForwardingRuleGetCall<'a, C, A> {} -impl<'a, C, NC, A> ForwardingRuleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ForwardingRuleGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -26646,7 +26642,7 @@ impl<'a, C, NC, A> ForwardingRuleGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> ForwardingRuleGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ForwardingRuleGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -26656,7 +26652,7 @@ impl<'a, C, NC, A> ForwardingRuleGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Name of the region scoping this request. - pub fn region(mut self, new_value: &str) -> ForwardingRuleGetCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> ForwardingRuleGetCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -26666,7 +26662,7 @@ impl<'a, C, NC, A> ForwardingRuleGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Name of the ForwardingRule resource to return. - pub fn forwarding_rule(mut self, new_value: &str) -> ForwardingRuleGetCall<'a, C, NC, A> { + pub fn forwarding_rule(mut self, new_value: &str) -> ForwardingRuleGetCall<'a, C, A> { self._forwarding_rule = new_value.to_string(); self } @@ -26677,7 +26673,7 @@ impl<'a, C, NC, A> ForwardingRuleGetCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ForwardingRuleGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ForwardingRuleGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -26698,7 +26694,7 @@ impl<'a, C, NC, A> ForwardingRuleGetCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ForwardingRuleGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ForwardingRuleGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -26715,7 +26711,7 @@ impl<'a, C, NC, A> ForwardingRuleGetCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ForwardingRuleGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ForwardingRuleGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -26756,10 +26752,10 @@ impl<'a, C, NC, A> ForwardingRuleGetCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct ForwardingRuleListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ForwardingRuleListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _region: String, _page_token: Option, @@ -26770,9 +26766,9 @@ pub struct ForwardingRuleListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ForwardingRuleListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ForwardingRuleListCall<'a, C, A> {} -impl<'a, C, NC, A> ForwardingRuleListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ForwardingRuleListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -26914,7 +26910,7 @@ impl<'a, C, NC, A> ForwardingRuleListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> ForwardingRuleListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ForwardingRuleListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -26924,7 +26920,7 @@ impl<'a, C, NC, A> ForwardingRuleListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Name of the region scoping this request. - pub fn region(mut self, new_value: &str) -> ForwardingRuleListCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> ForwardingRuleListCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -26932,7 +26928,7 @@ impl<'a, C, NC, A> ForwardingRuleListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> ForwardingRuleListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ForwardingRuleListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -26940,7 +26936,7 @@ impl<'a, C, NC, A> ForwardingRuleListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> ForwardingRuleListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> ForwardingRuleListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -26948,7 +26944,7 @@ impl<'a, C, NC, A> ForwardingRuleListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> ForwardingRuleListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> ForwardingRuleListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -26959,7 +26955,7 @@ impl<'a, C, NC, A> ForwardingRuleListCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ForwardingRuleListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ForwardingRuleListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -26980,7 +26976,7 @@ impl<'a, C, NC, A> ForwardingRuleListCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ForwardingRuleListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ForwardingRuleListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -26997,7 +26993,7 @@ impl<'a, C, NC, A> ForwardingRuleListCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ForwardingRuleListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ForwardingRuleListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -27035,10 +27031,10 @@ impl<'a, C, NC, A> ForwardingRuleListCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct ForwardingRuleDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ForwardingRuleDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _region: String, _forwarding_rule: String, @@ -27047,9 +27043,9 @@ pub struct ForwardingRuleDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ForwardingRuleDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ForwardingRuleDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ForwardingRuleDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ForwardingRuleDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -27183,7 +27179,7 @@ impl<'a, C, NC, A> ForwardingRuleDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> ForwardingRuleDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ForwardingRuleDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -27193,7 +27189,7 @@ impl<'a, C, NC, A> ForwardingRuleDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Name of the region scoping this request. - pub fn region(mut self, new_value: &str) -> ForwardingRuleDeleteCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> ForwardingRuleDeleteCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -27203,7 +27199,7 @@ impl<'a, C, NC, A> ForwardingRuleDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Name of the ForwardingRule resource to delete. - pub fn forwarding_rule(mut self, new_value: &str) -> ForwardingRuleDeleteCall<'a, C, NC, A> { + pub fn forwarding_rule(mut self, new_value: &str) -> ForwardingRuleDeleteCall<'a, C, A> { self._forwarding_rule = new_value.to_string(); self } @@ -27214,7 +27210,7 @@ impl<'a, C, NC, A> ForwardingRuleDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ForwardingRuleDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ForwardingRuleDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -27235,7 +27231,7 @@ impl<'a, C, NC, A> ForwardingRuleDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ForwardingRuleDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ForwardingRuleDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -27252,7 +27248,7 @@ impl<'a, C, NC, A> ForwardingRuleDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ForwardingRuleDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ForwardingRuleDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -27293,10 +27289,10 @@ impl<'a, C, NC, A> ForwardingRuleDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct TargetPoolListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetPoolListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _region: String, _page_token: Option, @@ -27307,9 +27303,9 @@ pub struct TargetPoolListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetPoolListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetPoolListCall<'a, C, A> {} -impl<'a, C, NC, A> TargetPoolListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetPoolListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -27451,7 +27447,7 @@ impl<'a, C, NC, A> TargetPoolListCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> TargetPoolListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetPoolListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -27461,7 +27457,7 @@ impl<'a, C, NC, A> TargetPoolListCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Name of the region scoping this request. - pub fn region(mut self, new_value: &str) -> TargetPoolListCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> TargetPoolListCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -27469,7 +27465,7 @@ impl<'a, C, NC, A> TargetPoolListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> TargetPoolListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TargetPoolListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -27477,7 +27473,7 @@ impl<'a, C, NC, A> TargetPoolListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> TargetPoolListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> TargetPoolListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -27485,7 +27481,7 @@ impl<'a, C, NC, A> TargetPoolListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> TargetPoolListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> TargetPoolListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -27496,7 +27492,7 @@ impl<'a, C, NC, A> TargetPoolListCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetPoolListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetPoolListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -27517,7 +27513,7 @@ impl<'a, C, NC, A> TargetPoolListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetPoolListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetPoolListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -27534,7 +27530,7 @@ impl<'a, C, NC, A> TargetPoolListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetPoolListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetPoolListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -27578,10 +27574,10 @@ impl<'a, C, NC, A> TargetPoolListCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct TargetPoolAddHealthCheckCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetPoolAddHealthCheckCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: TargetPoolsAddHealthCheckRequest, _project: String, _region: String, @@ -27591,9 +27587,9 @@ pub struct TargetPoolAddHealthCheckCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetPoolAddHealthCheckCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetPoolAddHealthCheckCall<'a, C, A> {} -impl<'a, C, NC, A> TargetPoolAddHealthCheckCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetPoolAddHealthCheckCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -27734,7 +27730,7 @@ impl<'a, C, NC, A> TargetPoolAddHealthCheckCall<'a, C, NC, A> where NC: hyper::n /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &TargetPoolsAddHealthCheckRequest) -> TargetPoolAddHealthCheckCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &TargetPoolsAddHealthCheckRequest) -> TargetPoolAddHealthCheckCall<'a, C, A> { self._request = new_value.clone(); self } @@ -27743,7 +27739,7 @@ impl<'a, C, NC, A> TargetPoolAddHealthCheckCall<'a, C, NC, A> where NC: hyper::n /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn project(mut self, new_value: &str) -> TargetPoolAddHealthCheckCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetPoolAddHealthCheckCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -27753,7 +27749,7 @@ impl<'a, C, NC, A> TargetPoolAddHealthCheckCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Name of the region scoping this request. - pub fn region(mut self, new_value: &str) -> TargetPoolAddHealthCheckCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> TargetPoolAddHealthCheckCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -27763,7 +27759,7 @@ impl<'a, C, NC, A> TargetPoolAddHealthCheckCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Name of the TargetPool resource to which health_check_url is to be added. - pub fn target_pool(mut self, new_value: &str) -> TargetPoolAddHealthCheckCall<'a, C, NC, A> { + pub fn target_pool(mut self, new_value: &str) -> TargetPoolAddHealthCheckCall<'a, C, A> { self._target_pool = new_value.to_string(); self } @@ -27774,7 +27770,7 @@ impl<'a, C, NC, A> TargetPoolAddHealthCheckCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetPoolAddHealthCheckCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetPoolAddHealthCheckCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -27795,7 +27791,7 @@ impl<'a, C, NC, A> TargetPoolAddHealthCheckCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetPoolAddHealthCheckCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetPoolAddHealthCheckCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -27812,7 +27808,7 @@ impl<'a, C, NC, A> TargetPoolAddHealthCheckCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetPoolAddHealthCheckCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetPoolAddHealthCheckCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -27856,10 +27852,10 @@ impl<'a, C, NC, A> TargetPoolAddHealthCheckCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct TargetPoolInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetPoolInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: TargetPool, _project: String, _region: String, @@ -27868,9 +27864,9 @@ pub struct TargetPoolInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetPoolInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetPoolInsertCall<'a, C, A> {} -impl<'a, C, NC, A> TargetPoolInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetPoolInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -28010,7 +28006,7 @@ impl<'a, C, NC, A> TargetPoolInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &TargetPool) -> TargetPoolInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &TargetPool) -> TargetPoolInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -28020,7 +28016,7 @@ impl<'a, C, NC, A> TargetPoolInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> TargetPoolInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetPoolInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -28030,7 +28026,7 @@ impl<'a, C, NC, A> TargetPoolInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Name of the region scoping this request. - pub fn region(mut self, new_value: &str) -> TargetPoolInsertCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> TargetPoolInsertCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -28041,7 +28037,7 @@ impl<'a, C, NC, A> TargetPoolInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetPoolInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetPoolInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -28062,7 +28058,7 @@ impl<'a, C, NC, A> TargetPoolInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetPoolInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetPoolInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -28079,7 +28075,7 @@ impl<'a, C, NC, A> TargetPoolInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetPoolInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetPoolInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -28123,10 +28119,10 @@ impl<'a, C, NC, A> TargetPoolInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct TargetPoolRemoveHealthCheckCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetPoolRemoveHealthCheckCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: TargetPoolsRemoveHealthCheckRequest, _project: String, _region: String, @@ -28136,9 +28132,9 @@ pub struct TargetPoolRemoveHealthCheckCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetPoolRemoveHealthCheckCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetPoolRemoveHealthCheckCall<'a, C, A> {} -impl<'a, C, NC, A> TargetPoolRemoveHealthCheckCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetPoolRemoveHealthCheckCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -28279,7 +28275,7 @@ impl<'a, C, NC, A> TargetPoolRemoveHealthCheckCall<'a, C, NC, A> where NC: hyper /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &TargetPoolsRemoveHealthCheckRequest) -> TargetPoolRemoveHealthCheckCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &TargetPoolsRemoveHealthCheckRequest) -> TargetPoolRemoveHealthCheckCall<'a, C, A> { self._request = new_value.clone(); self } @@ -28288,7 +28284,7 @@ impl<'a, C, NC, A> TargetPoolRemoveHealthCheckCall<'a, C, NC, A> where NC: hyper /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn project(mut self, new_value: &str) -> TargetPoolRemoveHealthCheckCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetPoolRemoveHealthCheckCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -28298,7 +28294,7 @@ impl<'a, C, NC, A> TargetPoolRemoveHealthCheckCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// Name of the region scoping this request. - pub fn region(mut self, new_value: &str) -> TargetPoolRemoveHealthCheckCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> TargetPoolRemoveHealthCheckCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -28308,7 +28304,7 @@ impl<'a, C, NC, A> TargetPoolRemoveHealthCheckCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// Name of the TargetPool resource to which health_check_url is to be removed. - pub fn target_pool(mut self, new_value: &str) -> TargetPoolRemoveHealthCheckCall<'a, C, NC, A> { + pub fn target_pool(mut self, new_value: &str) -> TargetPoolRemoveHealthCheckCall<'a, C, A> { self._target_pool = new_value.to_string(); self } @@ -28319,7 +28315,7 @@ impl<'a, C, NC, A> TargetPoolRemoveHealthCheckCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetPoolRemoveHealthCheckCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetPoolRemoveHealthCheckCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -28340,7 +28336,7 @@ impl<'a, C, NC, A> TargetPoolRemoveHealthCheckCall<'a, C, NC, A> where NC: hyper /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetPoolRemoveHealthCheckCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetPoolRemoveHealthCheckCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -28357,7 +28353,7 @@ impl<'a, C, NC, A> TargetPoolRemoveHealthCheckCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetPoolRemoveHealthCheckCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetPoolRemoveHealthCheckCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -28401,10 +28397,10 @@ impl<'a, C, NC, A> TargetPoolRemoveHealthCheckCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct TargetPoolGetHealthCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetPoolGetHealthCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: InstanceReference, _project: String, _region: String, @@ -28414,9 +28410,9 @@ pub struct TargetPoolGetHealthCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetPoolGetHealthCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetPoolGetHealthCall<'a, C, A> {} -impl<'a, C, NC, A> TargetPoolGetHealthCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetPoolGetHealthCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -28557,7 +28553,7 @@ impl<'a, C, NC, A> TargetPoolGetHealthCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &InstanceReference) -> TargetPoolGetHealthCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &InstanceReference) -> TargetPoolGetHealthCall<'a, C, A> { self._request = new_value.clone(); self } @@ -28566,7 +28562,7 @@ impl<'a, C, NC, A> TargetPoolGetHealthCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn project(mut self, new_value: &str) -> TargetPoolGetHealthCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetPoolGetHealthCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -28576,7 +28572,7 @@ impl<'a, C, NC, A> TargetPoolGetHealthCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Name of the region scoping this request. - pub fn region(mut self, new_value: &str) -> TargetPoolGetHealthCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> TargetPoolGetHealthCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -28586,7 +28582,7 @@ impl<'a, C, NC, A> TargetPoolGetHealthCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Name of the TargetPool resource to which the queried instance belongs. - pub fn target_pool(mut self, new_value: &str) -> TargetPoolGetHealthCall<'a, C, NC, A> { + pub fn target_pool(mut self, new_value: &str) -> TargetPoolGetHealthCall<'a, C, A> { self._target_pool = new_value.to_string(); self } @@ -28597,7 +28593,7 @@ impl<'a, C, NC, A> TargetPoolGetHealthCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetPoolGetHealthCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetPoolGetHealthCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -28618,7 +28614,7 @@ impl<'a, C, NC, A> TargetPoolGetHealthCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetPoolGetHealthCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetPoolGetHealthCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -28635,7 +28631,7 @@ impl<'a, C, NC, A> TargetPoolGetHealthCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetPoolGetHealthCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetPoolGetHealthCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -28680,10 +28676,10 @@ impl<'a, C, NC, A> TargetPoolGetHealthCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct TargetPoolSetBackupCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetPoolSetBackupCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: TargetReference, _project: String, _region: String, @@ -28694,9 +28690,9 @@ pub struct TargetPoolSetBackupCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetPoolSetBackupCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetPoolSetBackupCall<'a, C, A> {} -impl<'a, C, NC, A> TargetPoolSetBackupCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetPoolSetBackupCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -28840,7 +28836,7 @@ impl<'a, C, NC, A> TargetPoolSetBackupCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &TargetReference) -> TargetPoolSetBackupCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &TargetReference) -> TargetPoolSetBackupCall<'a, C, A> { self._request = new_value.clone(); self } @@ -28850,7 +28846,7 @@ impl<'a, C, NC, A> TargetPoolSetBackupCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> TargetPoolSetBackupCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetPoolSetBackupCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -28860,7 +28856,7 @@ impl<'a, C, NC, A> TargetPoolSetBackupCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Name of the region scoping this request. - pub fn region(mut self, new_value: &str) -> TargetPoolSetBackupCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> TargetPoolSetBackupCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -28870,7 +28866,7 @@ impl<'a, C, NC, A> TargetPoolSetBackupCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Name of the TargetPool resource for which the backup is to be set. - pub fn target_pool(mut self, new_value: &str) -> TargetPoolSetBackupCall<'a, C, NC, A> { + pub fn target_pool(mut self, new_value: &str) -> TargetPoolSetBackupCall<'a, C, A> { self._target_pool = new_value.to_string(); self } @@ -28878,7 +28874,7 @@ impl<'a, C, NC, A> TargetPoolSetBackupCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// New failoverRatio value for the containing target pool. - pub fn failover_ratio(mut self, new_value: f32) -> TargetPoolSetBackupCall<'a, C, NC, A> { + pub fn failover_ratio(mut self, new_value: f32) -> TargetPoolSetBackupCall<'a, C, A> { self._failover_ratio = Some(new_value); self } @@ -28889,7 +28885,7 @@ impl<'a, C, NC, A> TargetPoolSetBackupCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetPoolSetBackupCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetPoolSetBackupCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -28910,7 +28906,7 @@ impl<'a, C, NC, A> TargetPoolSetBackupCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetPoolSetBackupCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetPoolSetBackupCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -28927,7 +28923,7 @@ impl<'a, C, NC, A> TargetPoolSetBackupCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetPoolSetBackupCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetPoolSetBackupCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -28968,10 +28964,10 @@ impl<'a, C, NC, A> TargetPoolSetBackupCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct TargetPoolAggregatedListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetPoolAggregatedListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -28981,9 +28977,9 @@ pub struct TargetPoolAggregatedListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetPoolAggregatedListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetPoolAggregatedListCall<'a, C, A> {} -impl<'a, C, NC, A> TargetPoolAggregatedListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetPoolAggregatedListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -29124,7 +29120,7 @@ impl<'a, C, NC, A> TargetPoolAggregatedListCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> TargetPoolAggregatedListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetPoolAggregatedListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -29132,7 +29128,7 @@ impl<'a, C, NC, A> TargetPoolAggregatedListCall<'a, C, NC, A> where NC: hyper::n /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> TargetPoolAggregatedListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TargetPoolAggregatedListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -29140,7 +29136,7 @@ impl<'a, C, NC, A> TargetPoolAggregatedListCall<'a, C, NC, A> where NC: hyper::n /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> TargetPoolAggregatedListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> TargetPoolAggregatedListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -29148,7 +29144,7 @@ impl<'a, C, NC, A> TargetPoolAggregatedListCall<'a, C, NC, A> where NC: hyper::n /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> TargetPoolAggregatedListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> TargetPoolAggregatedListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -29159,7 +29155,7 @@ impl<'a, C, NC, A> TargetPoolAggregatedListCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetPoolAggregatedListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetPoolAggregatedListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -29180,7 +29176,7 @@ impl<'a, C, NC, A> TargetPoolAggregatedListCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetPoolAggregatedListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetPoolAggregatedListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -29197,7 +29193,7 @@ impl<'a, C, NC, A> TargetPoolAggregatedListCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetPoolAggregatedListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetPoolAggregatedListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -29235,10 +29231,10 @@ impl<'a, C, NC, A> TargetPoolAggregatedListCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct TargetPoolGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetPoolGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _region: String, _target_pool: String, @@ -29247,9 +29243,9 @@ pub struct TargetPoolGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetPoolGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetPoolGetCall<'a, C, A> {} -impl<'a, C, NC, A> TargetPoolGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetPoolGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -29383,7 +29379,7 @@ impl<'a, C, NC, A> TargetPoolGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> TargetPoolGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetPoolGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -29393,7 +29389,7 @@ impl<'a, C, NC, A> TargetPoolGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Name of the region scoping this request. - pub fn region(mut self, new_value: &str) -> TargetPoolGetCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> TargetPoolGetCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -29403,7 +29399,7 @@ impl<'a, C, NC, A> TargetPoolGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Name of the TargetPool resource to return. - pub fn target_pool(mut self, new_value: &str) -> TargetPoolGetCall<'a, C, NC, A> { + pub fn target_pool(mut self, new_value: &str) -> TargetPoolGetCall<'a, C, A> { self._target_pool = new_value.to_string(); self } @@ -29414,7 +29410,7 @@ impl<'a, C, NC, A> TargetPoolGetCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetPoolGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetPoolGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -29435,7 +29431,7 @@ impl<'a, C, NC, A> TargetPoolGetCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetPoolGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetPoolGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -29452,7 +29448,7 @@ impl<'a, C, NC, A> TargetPoolGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetPoolGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetPoolGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -29496,10 +29492,10 @@ impl<'a, C, NC, A> TargetPoolGetCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct TargetPoolAddInstanceCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetPoolAddInstanceCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: TargetPoolsAddInstanceRequest, _project: String, _region: String, @@ -29509,9 +29505,9 @@ pub struct TargetPoolAddInstanceCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetPoolAddInstanceCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetPoolAddInstanceCall<'a, C, A> {} -impl<'a, C, NC, A> TargetPoolAddInstanceCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetPoolAddInstanceCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -29652,7 +29648,7 @@ impl<'a, C, NC, A> TargetPoolAddInstanceCall<'a, C, NC, A> where NC: hyper::net: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &TargetPoolsAddInstanceRequest) -> TargetPoolAddInstanceCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &TargetPoolsAddInstanceRequest) -> TargetPoolAddInstanceCall<'a, C, A> { self._request = new_value.clone(); self } @@ -29661,7 +29657,7 @@ impl<'a, C, NC, A> TargetPoolAddInstanceCall<'a, C, NC, A> where NC: hyper::net: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn project(mut self, new_value: &str) -> TargetPoolAddInstanceCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetPoolAddInstanceCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -29671,7 +29667,7 @@ impl<'a, C, NC, A> TargetPoolAddInstanceCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Name of the region scoping this request. - pub fn region(mut self, new_value: &str) -> TargetPoolAddInstanceCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> TargetPoolAddInstanceCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -29681,7 +29677,7 @@ impl<'a, C, NC, A> TargetPoolAddInstanceCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Name of the TargetPool resource to which instance_url is to be added. - pub fn target_pool(mut self, new_value: &str) -> TargetPoolAddInstanceCall<'a, C, NC, A> { + pub fn target_pool(mut self, new_value: &str) -> TargetPoolAddInstanceCall<'a, C, A> { self._target_pool = new_value.to_string(); self } @@ -29692,7 +29688,7 @@ impl<'a, C, NC, A> TargetPoolAddInstanceCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetPoolAddInstanceCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetPoolAddInstanceCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -29713,7 +29709,7 @@ impl<'a, C, NC, A> TargetPoolAddInstanceCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetPoolAddInstanceCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetPoolAddInstanceCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -29730,7 +29726,7 @@ impl<'a, C, NC, A> TargetPoolAddInstanceCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetPoolAddInstanceCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetPoolAddInstanceCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -29774,10 +29770,10 @@ impl<'a, C, NC, A> TargetPoolAddInstanceCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct TargetPoolRemoveInstanceCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetPoolRemoveInstanceCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: TargetPoolsRemoveInstanceRequest, _project: String, _region: String, @@ -29787,9 +29783,9 @@ pub struct TargetPoolRemoveInstanceCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetPoolRemoveInstanceCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetPoolRemoveInstanceCall<'a, C, A> {} -impl<'a, C, NC, A> TargetPoolRemoveInstanceCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetPoolRemoveInstanceCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -29930,7 +29926,7 @@ impl<'a, C, NC, A> TargetPoolRemoveInstanceCall<'a, C, NC, A> where NC: hyper::n /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &TargetPoolsRemoveInstanceRequest) -> TargetPoolRemoveInstanceCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &TargetPoolsRemoveInstanceRequest) -> TargetPoolRemoveInstanceCall<'a, C, A> { self._request = new_value.clone(); self } @@ -29939,7 +29935,7 @@ impl<'a, C, NC, A> TargetPoolRemoveInstanceCall<'a, C, NC, A> where NC: hyper::n /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn project(mut self, new_value: &str) -> TargetPoolRemoveInstanceCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetPoolRemoveInstanceCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -29949,7 +29945,7 @@ impl<'a, C, NC, A> TargetPoolRemoveInstanceCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Name of the region scoping this request. - pub fn region(mut self, new_value: &str) -> TargetPoolRemoveInstanceCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> TargetPoolRemoveInstanceCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -29959,7 +29955,7 @@ impl<'a, C, NC, A> TargetPoolRemoveInstanceCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Name of the TargetPool resource to which instance_url is to be removed. - pub fn target_pool(mut self, new_value: &str) -> TargetPoolRemoveInstanceCall<'a, C, NC, A> { + pub fn target_pool(mut self, new_value: &str) -> TargetPoolRemoveInstanceCall<'a, C, A> { self._target_pool = new_value.to_string(); self } @@ -29970,7 +29966,7 @@ impl<'a, C, NC, A> TargetPoolRemoveInstanceCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetPoolRemoveInstanceCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetPoolRemoveInstanceCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -29991,7 +29987,7 @@ impl<'a, C, NC, A> TargetPoolRemoveInstanceCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetPoolRemoveInstanceCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetPoolRemoveInstanceCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -30008,7 +30004,7 @@ impl<'a, C, NC, A> TargetPoolRemoveInstanceCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetPoolRemoveInstanceCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetPoolRemoveInstanceCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -30046,10 +30042,10 @@ impl<'a, C, NC, A> TargetPoolRemoveInstanceCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct TargetPoolDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetPoolDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _region: String, _target_pool: String, @@ -30058,9 +30054,9 @@ pub struct TargetPoolDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetPoolDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetPoolDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> TargetPoolDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetPoolDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -30194,7 +30190,7 @@ impl<'a, C, NC, A> TargetPoolDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> TargetPoolDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetPoolDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -30204,7 +30200,7 @@ impl<'a, C, NC, A> TargetPoolDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Name of the region scoping this request. - pub fn region(mut self, new_value: &str) -> TargetPoolDeleteCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> TargetPoolDeleteCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -30214,7 +30210,7 @@ impl<'a, C, NC, A> TargetPoolDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Name of the TargetPool resource to delete. - pub fn target_pool(mut self, new_value: &str) -> TargetPoolDeleteCall<'a, C, NC, A> { + pub fn target_pool(mut self, new_value: &str) -> TargetPoolDeleteCall<'a, C, A> { self._target_pool = new_value.to_string(); self } @@ -30225,7 +30221,7 @@ impl<'a, C, NC, A> TargetPoolDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetPoolDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetPoolDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -30246,7 +30242,7 @@ impl<'a, C, NC, A> TargetPoolDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetPoolDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetPoolDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -30263,7 +30259,7 @@ impl<'a, C, NC, A> TargetPoolDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetPoolDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetPoolDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -30304,10 +30300,10 @@ impl<'a, C, NC, A> TargetPoolDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct TargetInstanceListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetInstanceListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _page_token: Option, @@ -30318,9 +30314,9 @@ pub struct TargetInstanceListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetInstanceListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetInstanceListCall<'a, C, A> {} -impl<'a, C, NC, A> TargetInstanceListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetInstanceListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -30462,7 +30458,7 @@ impl<'a, C, NC, A> TargetInstanceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> TargetInstanceListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetInstanceListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -30472,7 +30468,7 @@ impl<'a, C, NC, A> TargetInstanceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Name of the zone scoping this request. - pub fn zone(mut self, new_value: &str) -> TargetInstanceListCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> TargetInstanceListCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -30480,7 +30476,7 @@ impl<'a, C, NC, A> TargetInstanceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> TargetInstanceListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TargetInstanceListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -30488,7 +30484,7 @@ impl<'a, C, NC, A> TargetInstanceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> TargetInstanceListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> TargetInstanceListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -30496,7 +30492,7 @@ impl<'a, C, NC, A> TargetInstanceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> TargetInstanceListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> TargetInstanceListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -30507,7 +30503,7 @@ impl<'a, C, NC, A> TargetInstanceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetInstanceListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetInstanceListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -30528,7 +30524,7 @@ impl<'a, C, NC, A> TargetInstanceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetInstanceListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetInstanceListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -30545,7 +30541,7 @@ impl<'a, C, NC, A> TargetInstanceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetInstanceListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetInstanceListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -30589,10 +30585,10 @@ impl<'a, C, NC, A> TargetInstanceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct TargetInstanceInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetInstanceInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: TargetInstance, _project: String, _zone: String, @@ -30601,9 +30597,9 @@ pub struct TargetInstanceInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetInstanceInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetInstanceInsertCall<'a, C, A> {} -impl<'a, C, NC, A> TargetInstanceInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetInstanceInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -30743,7 +30739,7 @@ impl<'a, C, NC, A> TargetInstanceInsertCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &TargetInstance) -> TargetInstanceInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &TargetInstance) -> TargetInstanceInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -30753,7 +30749,7 @@ impl<'a, C, NC, A> TargetInstanceInsertCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> TargetInstanceInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetInstanceInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -30763,7 +30759,7 @@ impl<'a, C, NC, A> TargetInstanceInsertCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Name of the zone scoping this request. - pub fn zone(mut self, new_value: &str) -> TargetInstanceInsertCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> TargetInstanceInsertCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -30774,7 +30770,7 @@ impl<'a, C, NC, A> TargetInstanceInsertCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetInstanceInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetInstanceInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -30795,7 +30791,7 @@ impl<'a, C, NC, A> TargetInstanceInsertCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetInstanceInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetInstanceInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -30812,7 +30808,7 @@ impl<'a, C, NC, A> TargetInstanceInsertCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetInstanceInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetInstanceInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -30853,10 +30849,10 @@ impl<'a, C, NC, A> TargetInstanceInsertCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct TargetInstanceAggregatedListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetInstanceAggregatedListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -30866,9 +30862,9 @@ pub struct TargetInstanceAggregatedListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetInstanceAggregatedListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetInstanceAggregatedListCall<'a, C, A> {} -impl<'a, C, NC, A> TargetInstanceAggregatedListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetInstanceAggregatedListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -31009,7 +31005,7 @@ impl<'a, C, NC, A> TargetInstanceAggregatedListCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> TargetInstanceAggregatedListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetInstanceAggregatedListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -31017,7 +31013,7 @@ impl<'a, C, NC, A> TargetInstanceAggregatedListCall<'a, C, NC, A> where NC: hype /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> TargetInstanceAggregatedListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TargetInstanceAggregatedListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -31025,7 +31021,7 @@ impl<'a, C, NC, A> TargetInstanceAggregatedListCall<'a, C, NC, A> where NC: hype /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> TargetInstanceAggregatedListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> TargetInstanceAggregatedListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -31033,7 +31029,7 @@ impl<'a, C, NC, A> TargetInstanceAggregatedListCall<'a, C, NC, A> where NC: hype /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> TargetInstanceAggregatedListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> TargetInstanceAggregatedListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -31044,7 +31040,7 @@ impl<'a, C, NC, A> TargetInstanceAggregatedListCall<'a, C, NC, A> where NC: hype /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetInstanceAggregatedListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetInstanceAggregatedListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -31065,7 +31061,7 @@ impl<'a, C, NC, A> TargetInstanceAggregatedListCall<'a, C, NC, A> where NC: hype /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetInstanceAggregatedListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetInstanceAggregatedListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -31082,7 +31078,7 @@ impl<'a, C, NC, A> TargetInstanceAggregatedListCall<'a, C, NC, A> where NC: hype /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetInstanceAggregatedListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetInstanceAggregatedListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -31120,10 +31116,10 @@ impl<'a, C, NC, A> TargetInstanceAggregatedListCall<'a, C, NC, A> where NC: hype /// .doit(); /// # } /// ``` -pub struct TargetInstanceGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetInstanceGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _target_instance: String, @@ -31132,9 +31128,9 @@ pub struct TargetInstanceGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetInstanceGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetInstanceGetCall<'a, C, A> {} -impl<'a, C, NC, A> TargetInstanceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetInstanceGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -31268,7 +31264,7 @@ impl<'a, C, NC, A> TargetInstanceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> TargetInstanceGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetInstanceGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -31278,7 +31274,7 @@ impl<'a, C, NC, A> TargetInstanceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Name of the zone scoping this request. - pub fn zone(mut self, new_value: &str) -> TargetInstanceGetCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> TargetInstanceGetCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -31288,7 +31284,7 @@ impl<'a, C, NC, A> TargetInstanceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Name of the TargetInstance resource to return. - pub fn target_instance(mut self, new_value: &str) -> TargetInstanceGetCall<'a, C, NC, A> { + pub fn target_instance(mut self, new_value: &str) -> TargetInstanceGetCall<'a, C, A> { self._target_instance = new_value.to_string(); self } @@ -31299,7 +31295,7 @@ impl<'a, C, NC, A> TargetInstanceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetInstanceGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetInstanceGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -31320,7 +31316,7 @@ impl<'a, C, NC, A> TargetInstanceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetInstanceGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetInstanceGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -31337,7 +31333,7 @@ impl<'a, C, NC, A> TargetInstanceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetInstanceGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetInstanceGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -31375,10 +31371,10 @@ impl<'a, C, NC, A> TargetInstanceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct TargetInstanceDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetInstanceDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _target_instance: String, @@ -31387,9 +31383,9 @@ pub struct TargetInstanceDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetInstanceDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetInstanceDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> TargetInstanceDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetInstanceDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -31523,7 +31519,7 @@ impl<'a, C, NC, A> TargetInstanceDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> TargetInstanceDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetInstanceDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -31533,7 +31529,7 @@ impl<'a, C, NC, A> TargetInstanceDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Name of the zone scoping this request. - pub fn zone(mut self, new_value: &str) -> TargetInstanceDeleteCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> TargetInstanceDeleteCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -31543,7 +31539,7 @@ impl<'a, C, NC, A> TargetInstanceDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Name of the TargetInstance resource to delete. - pub fn target_instance(mut self, new_value: &str) -> TargetInstanceDeleteCall<'a, C, NC, A> { + pub fn target_instance(mut self, new_value: &str) -> TargetInstanceDeleteCall<'a, C, A> { self._target_instance = new_value.to_string(); self } @@ -31554,7 +31550,7 @@ impl<'a, C, NC, A> TargetInstanceDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetInstanceDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetInstanceDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -31575,7 +31571,7 @@ impl<'a, C, NC, A> TargetInstanceDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetInstanceDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetInstanceDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -31592,7 +31588,7 @@ impl<'a, C, NC, A> TargetInstanceDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetInstanceDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetInstanceDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -31630,10 +31626,10 @@ impl<'a, C, NC, A> TargetInstanceDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct GlobalForwardingRuleGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GlobalForwardingRuleGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _forwarding_rule: String, _delegate: Option<&'a mut Delegate>, @@ -31641,9 +31637,9 @@ pub struct GlobalForwardingRuleGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GlobalForwardingRuleGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GlobalForwardingRuleGetCall<'a, C, A> {} -impl<'a, C, NC, A> GlobalForwardingRuleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GlobalForwardingRuleGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -31776,7 +31772,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> GlobalForwardingRuleGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> GlobalForwardingRuleGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -31786,7 +31782,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Name of the ForwardingRule resource to return. - pub fn forwarding_rule(mut self, new_value: &str) -> GlobalForwardingRuleGetCall<'a, C, NC, A> { + pub fn forwarding_rule(mut self, new_value: &str) -> GlobalForwardingRuleGetCall<'a, C, A> { self._forwarding_rule = new_value.to_string(); self } @@ -31797,7 +31793,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleGetCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalForwardingRuleGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalForwardingRuleGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -31818,7 +31814,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleGetCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GlobalForwardingRuleGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GlobalForwardingRuleGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -31835,7 +31831,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleGetCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GlobalForwardingRuleGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GlobalForwardingRuleGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -31873,10 +31869,10 @@ impl<'a, C, NC, A> GlobalForwardingRuleGetCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct GlobalForwardingRuleDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GlobalForwardingRuleDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _forwarding_rule: String, _delegate: Option<&'a mut Delegate>, @@ -31884,9 +31880,9 @@ pub struct GlobalForwardingRuleDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GlobalForwardingRuleDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GlobalForwardingRuleDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> GlobalForwardingRuleDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GlobalForwardingRuleDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -32019,7 +32015,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleDeleteCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> GlobalForwardingRuleDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> GlobalForwardingRuleDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -32029,7 +32025,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleDeleteCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Name of the ForwardingRule resource to delete. - pub fn forwarding_rule(mut self, new_value: &str) -> GlobalForwardingRuleDeleteCall<'a, C, NC, A> { + pub fn forwarding_rule(mut self, new_value: &str) -> GlobalForwardingRuleDeleteCall<'a, C, A> { self._forwarding_rule = new_value.to_string(); self } @@ -32040,7 +32036,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleDeleteCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalForwardingRuleDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalForwardingRuleDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -32061,7 +32057,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleDeleteCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GlobalForwardingRuleDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GlobalForwardingRuleDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -32078,7 +32074,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleDeleteCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GlobalForwardingRuleDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GlobalForwardingRuleDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -32122,10 +32118,10 @@ impl<'a, C, NC, A> GlobalForwardingRuleDeleteCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct GlobalForwardingRuleSetTargetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GlobalForwardingRuleSetTargetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: TargetReference, _project: String, _forwarding_rule: String, @@ -32134,9 +32130,9 @@ pub struct GlobalForwardingRuleSetTargetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GlobalForwardingRuleSetTargetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GlobalForwardingRuleSetTargetCall<'a, C, A> {} -impl<'a, C, NC, A> GlobalForwardingRuleSetTargetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GlobalForwardingRuleSetTargetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -32276,7 +32272,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleSetTargetCall<'a, C, NC, A> where NC: hyp /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &TargetReference) -> GlobalForwardingRuleSetTargetCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &TargetReference) -> GlobalForwardingRuleSetTargetCall<'a, C, A> { self._request = new_value.clone(); self } @@ -32286,7 +32282,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleSetTargetCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> GlobalForwardingRuleSetTargetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> GlobalForwardingRuleSetTargetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -32296,7 +32292,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleSetTargetCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// Name of the ForwardingRule resource in which target is to be set. - pub fn forwarding_rule(mut self, new_value: &str) -> GlobalForwardingRuleSetTargetCall<'a, C, NC, A> { + pub fn forwarding_rule(mut self, new_value: &str) -> GlobalForwardingRuleSetTargetCall<'a, C, A> { self._forwarding_rule = new_value.to_string(); self } @@ -32307,7 +32303,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleSetTargetCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalForwardingRuleSetTargetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalForwardingRuleSetTargetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -32328,7 +32324,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleSetTargetCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GlobalForwardingRuleSetTargetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GlobalForwardingRuleSetTargetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -32345,7 +32341,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleSetTargetCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GlobalForwardingRuleSetTargetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GlobalForwardingRuleSetTargetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -32389,10 +32385,10 @@ impl<'a, C, NC, A> GlobalForwardingRuleSetTargetCall<'a, C, NC, A> where NC: hyp /// .doit(); /// # } /// ``` -pub struct GlobalForwardingRuleInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GlobalForwardingRuleInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: ForwardingRule, _project: String, _delegate: Option<&'a mut Delegate>, @@ -32400,9 +32396,9 @@ pub struct GlobalForwardingRuleInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GlobalForwardingRuleInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GlobalForwardingRuleInsertCall<'a, C, A> {} -impl<'a, C, NC, A> GlobalForwardingRuleInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GlobalForwardingRuleInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -32541,7 +32537,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleInsertCall<'a, C, NC, A> where NC: hyper: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ForwardingRule) -> GlobalForwardingRuleInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ForwardingRule) -> GlobalForwardingRuleInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -32551,7 +32547,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleInsertCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> GlobalForwardingRuleInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> GlobalForwardingRuleInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -32562,7 +32558,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleInsertCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalForwardingRuleInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalForwardingRuleInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -32583,7 +32579,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleInsertCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GlobalForwardingRuleInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GlobalForwardingRuleInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -32600,7 +32596,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleInsertCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GlobalForwardingRuleInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GlobalForwardingRuleInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -32641,10 +32637,10 @@ impl<'a, C, NC, A> GlobalForwardingRuleInsertCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct GlobalForwardingRuleListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GlobalForwardingRuleListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -32654,9 +32650,9 @@ pub struct GlobalForwardingRuleListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GlobalForwardingRuleListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GlobalForwardingRuleListCall<'a, C, A> {} -impl<'a, C, NC, A> GlobalForwardingRuleListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GlobalForwardingRuleListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -32797,7 +32793,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleListCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> GlobalForwardingRuleListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> GlobalForwardingRuleListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -32805,7 +32801,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleListCall<'a, C, NC, A> where NC: hyper::n /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> GlobalForwardingRuleListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> GlobalForwardingRuleListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -32813,7 +32809,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleListCall<'a, C, NC, A> where NC: hyper::n /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> GlobalForwardingRuleListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> GlobalForwardingRuleListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -32821,7 +32817,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleListCall<'a, C, NC, A> where NC: hyper::n /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> GlobalForwardingRuleListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> GlobalForwardingRuleListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -32832,7 +32828,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleListCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalForwardingRuleListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GlobalForwardingRuleListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -32853,7 +32849,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleListCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GlobalForwardingRuleListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GlobalForwardingRuleListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -32870,7 +32866,7 @@ impl<'a, C, NC, A> GlobalForwardingRuleListCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GlobalForwardingRuleListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GlobalForwardingRuleListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -32911,10 +32907,10 @@ impl<'a, C, NC, A> GlobalForwardingRuleListCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct ImageListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ImageListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -32924,9 +32920,9 @@ pub struct ImageListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ImageListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ImageListCall<'a, C, A> {} -impl<'a, C, NC, A> ImageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ImageListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -33067,7 +33063,7 @@ impl<'a, C, NC, A> ImageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> ImageListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ImageListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -33075,7 +33071,7 @@ impl<'a, C, NC, A> ImageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> ImageListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ImageListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -33083,7 +33079,7 @@ impl<'a, C, NC, A> ImageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> ImageListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> ImageListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -33091,7 +33087,7 @@ impl<'a, C, NC, A> ImageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> ImageListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> ImageListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -33102,7 +33098,7 @@ impl<'a, C, NC, A> ImageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ImageListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ImageListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -33123,7 +33119,7 @@ impl<'a, C, NC, A> ImageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ImageListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ImageListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -33140,7 +33136,7 @@ impl<'a, C, NC, A> ImageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ImageListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ImageListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -33178,10 +33174,10 @@ impl<'a, C, NC, A> ImageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct ImageDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ImageDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _image: String, _delegate: Option<&'a mut Delegate>, @@ -33189,9 +33185,9 @@ pub struct ImageDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ImageDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ImageDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ImageDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ImageDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -33324,7 +33320,7 @@ impl<'a, C, NC, A> ImageDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> ImageDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ImageDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -33334,7 +33330,7 @@ impl<'a, C, NC, A> ImageDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Name of the image resource to delete. - pub fn image(mut self, new_value: &str) -> ImageDeleteCall<'a, C, NC, A> { + pub fn image(mut self, new_value: &str) -> ImageDeleteCall<'a, C, A> { self._image = new_value.to_string(); self } @@ -33345,7 +33341,7 @@ impl<'a, C, NC, A> ImageDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ImageDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ImageDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -33366,7 +33362,7 @@ impl<'a, C, NC, A> ImageDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ImageDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ImageDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -33383,7 +33379,7 @@ impl<'a, C, NC, A> ImageDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ImageDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ImageDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -33429,10 +33425,10 @@ impl<'a, C, NC, A> ImageDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct ImageDeprecateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ImageDeprecateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: DeprecationStatus, _project: String, _image: String, @@ -33441,9 +33437,9 @@ pub struct ImageDeprecateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ImageDeprecateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ImageDeprecateCall<'a, C, A> {} -impl<'a, C, NC, A> ImageDeprecateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ImageDeprecateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -33583,7 +33579,7 @@ impl<'a, C, NC, A> ImageDeprecateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &DeprecationStatus) -> ImageDeprecateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &DeprecationStatus) -> ImageDeprecateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -33593,7 +33589,7 @@ impl<'a, C, NC, A> ImageDeprecateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> ImageDeprecateCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ImageDeprecateCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -33603,7 +33599,7 @@ impl<'a, C, NC, A> ImageDeprecateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Image name. - pub fn image(mut self, new_value: &str) -> ImageDeprecateCall<'a, C, NC, A> { + pub fn image(mut self, new_value: &str) -> ImageDeprecateCall<'a, C, A> { self._image = new_value.to_string(); self } @@ -33614,7 +33610,7 @@ impl<'a, C, NC, A> ImageDeprecateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ImageDeprecateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ImageDeprecateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -33635,7 +33631,7 @@ impl<'a, C, NC, A> ImageDeprecateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ImageDeprecateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ImageDeprecateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -33652,7 +33648,7 @@ impl<'a, C, NC, A> ImageDeprecateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ImageDeprecateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ImageDeprecateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -33696,10 +33692,10 @@ impl<'a, C, NC, A> ImageDeprecateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct ImageInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ImageInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: Image, _project: String, _delegate: Option<&'a mut Delegate>, @@ -33707,9 +33703,9 @@ pub struct ImageInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ImageInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ImageInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ImageInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ImageInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -33848,7 +33844,7 @@ impl<'a, C, NC, A> ImageInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Image) -> ImageInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Image) -> ImageInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -33858,7 +33854,7 @@ impl<'a, C, NC, A> ImageInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> ImageInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ImageInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -33869,7 +33865,7 @@ impl<'a, C, NC, A> ImageInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ImageInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ImageInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -33890,7 +33886,7 @@ impl<'a, C, NC, A> ImageInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ImageInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ImageInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -33907,7 +33903,7 @@ impl<'a, C, NC, A> ImageInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ImageInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ImageInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -33945,10 +33941,10 @@ impl<'a, C, NC, A> ImageInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct ImageGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ImageGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _image: String, _delegate: Option<&'a mut Delegate>, @@ -33956,9 +33952,9 @@ pub struct ImageGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ImageGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ImageGetCall<'a, C, A> {} -impl<'a, C, NC, A> ImageGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ImageGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -34091,7 +34087,7 @@ impl<'a, C, NC, A> ImageGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> ImageGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ImageGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -34101,7 +34097,7 @@ impl<'a, C, NC, A> ImageGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Name of the image resource to return. - pub fn image(mut self, new_value: &str) -> ImageGetCall<'a, C, NC, A> { + pub fn image(mut self, new_value: &str) -> ImageGetCall<'a, C, A> { self._image = new_value.to_string(); self } @@ -34112,7 +34108,7 @@ impl<'a, C, NC, A> ImageGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ImageGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ImageGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -34133,7 +34129,7 @@ impl<'a, C, NC, A> ImageGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ImageGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ImageGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -34150,7 +34146,7 @@ impl<'a, C, NC, A> ImageGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ImageGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ImageGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -34191,10 +34187,10 @@ impl<'a, C, NC, A> ImageGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct MachineTypeAggregatedListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MachineTypeAggregatedListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -34204,9 +34200,9 @@ pub struct MachineTypeAggregatedListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MachineTypeAggregatedListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MachineTypeAggregatedListCall<'a, C, A> {} -impl<'a, C, NC, A> MachineTypeAggregatedListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MachineTypeAggregatedListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -34347,7 +34343,7 @@ impl<'a, C, NC, A> MachineTypeAggregatedListCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> MachineTypeAggregatedListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> MachineTypeAggregatedListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -34355,7 +34351,7 @@ impl<'a, C, NC, A> MachineTypeAggregatedListCall<'a, C, NC, A> where NC: hyper:: /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> MachineTypeAggregatedListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> MachineTypeAggregatedListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -34363,7 +34359,7 @@ impl<'a, C, NC, A> MachineTypeAggregatedListCall<'a, C, NC, A> where NC: hyper:: /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> MachineTypeAggregatedListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> MachineTypeAggregatedListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -34371,7 +34367,7 @@ impl<'a, C, NC, A> MachineTypeAggregatedListCall<'a, C, NC, A> where NC: hyper:: /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> MachineTypeAggregatedListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> MachineTypeAggregatedListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -34382,7 +34378,7 @@ impl<'a, C, NC, A> MachineTypeAggregatedListCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MachineTypeAggregatedListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MachineTypeAggregatedListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -34403,7 +34399,7 @@ impl<'a, C, NC, A> MachineTypeAggregatedListCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MachineTypeAggregatedListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MachineTypeAggregatedListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -34420,7 +34416,7 @@ impl<'a, C, NC, A> MachineTypeAggregatedListCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MachineTypeAggregatedListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MachineTypeAggregatedListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -34458,10 +34454,10 @@ impl<'a, C, NC, A> MachineTypeAggregatedListCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct MachineTypeGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MachineTypeGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _machine_type: String, @@ -34470,9 +34466,9 @@ pub struct MachineTypeGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MachineTypeGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MachineTypeGetCall<'a, C, A> {} -impl<'a, C, NC, A> MachineTypeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MachineTypeGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -34606,7 +34602,7 @@ impl<'a, C, NC, A> MachineTypeGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> MachineTypeGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> MachineTypeGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -34616,7 +34612,7 @@ impl<'a, C, NC, A> MachineTypeGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> MachineTypeGetCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> MachineTypeGetCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -34626,7 +34622,7 @@ impl<'a, C, NC, A> MachineTypeGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Name of the machine type resource to return. - pub fn machine_type(mut self, new_value: &str) -> MachineTypeGetCall<'a, C, NC, A> { + pub fn machine_type(mut self, new_value: &str) -> MachineTypeGetCall<'a, C, A> { self._machine_type = new_value.to_string(); self } @@ -34637,7 +34633,7 @@ impl<'a, C, NC, A> MachineTypeGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MachineTypeGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MachineTypeGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -34658,7 +34654,7 @@ impl<'a, C, NC, A> MachineTypeGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MachineTypeGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MachineTypeGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -34675,7 +34671,7 @@ impl<'a, C, NC, A> MachineTypeGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MachineTypeGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MachineTypeGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -34716,10 +34712,10 @@ impl<'a, C, NC, A> MachineTypeGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct MachineTypeListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MachineTypeListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _page_token: Option, @@ -34730,9 +34726,9 @@ pub struct MachineTypeListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MachineTypeListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MachineTypeListCall<'a, C, A> {} -impl<'a, C, NC, A> MachineTypeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MachineTypeListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -34874,7 +34870,7 @@ impl<'a, C, NC, A> MachineTypeListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> MachineTypeListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> MachineTypeListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -34884,7 +34880,7 @@ impl<'a, C, NC, A> MachineTypeListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The name of the zone for this request. - pub fn zone(mut self, new_value: &str) -> MachineTypeListCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> MachineTypeListCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -34892,7 +34888,7 @@ impl<'a, C, NC, A> MachineTypeListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> MachineTypeListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> MachineTypeListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -34900,7 +34896,7 @@ impl<'a, C, NC, A> MachineTypeListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> MachineTypeListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> MachineTypeListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -34908,7 +34904,7 @@ impl<'a, C, NC, A> MachineTypeListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> MachineTypeListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> MachineTypeListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -34919,7 +34915,7 @@ impl<'a, C, NC, A> MachineTypeListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MachineTypeListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MachineTypeListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -34940,7 +34936,7 @@ impl<'a, C, NC, A> MachineTypeListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MachineTypeListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MachineTypeListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -34957,7 +34953,7 @@ impl<'a, C, NC, A> MachineTypeListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MachineTypeListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MachineTypeListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -34998,10 +34994,10 @@ impl<'a, C, NC, A> MachineTypeListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct TargetVpnGatewayAggregatedListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetVpnGatewayAggregatedListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -35011,9 +35007,9 @@ pub struct TargetVpnGatewayAggregatedListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetVpnGatewayAggregatedListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetVpnGatewayAggregatedListCall<'a, C, A> {} -impl<'a, C, NC, A> TargetVpnGatewayAggregatedListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetVpnGatewayAggregatedListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -35154,7 +35150,7 @@ impl<'a, C, NC, A> TargetVpnGatewayAggregatedListCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> TargetVpnGatewayAggregatedListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetVpnGatewayAggregatedListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -35162,7 +35158,7 @@ impl<'a, C, NC, A> TargetVpnGatewayAggregatedListCall<'a, C, NC, A> where NC: hy /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> TargetVpnGatewayAggregatedListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TargetVpnGatewayAggregatedListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -35170,7 +35166,7 @@ impl<'a, C, NC, A> TargetVpnGatewayAggregatedListCall<'a, C, NC, A> where NC: hy /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> TargetVpnGatewayAggregatedListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> TargetVpnGatewayAggregatedListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -35178,7 +35174,7 @@ impl<'a, C, NC, A> TargetVpnGatewayAggregatedListCall<'a, C, NC, A> where NC: hy /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> TargetVpnGatewayAggregatedListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> TargetVpnGatewayAggregatedListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -35189,7 +35185,7 @@ impl<'a, C, NC, A> TargetVpnGatewayAggregatedListCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetVpnGatewayAggregatedListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetVpnGatewayAggregatedListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -35210,7 +35206,7 @@ impl<'a, C, NC, A> TargetVpnGatewayAggregatedListCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetVpnGatewayAggregatedListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetVpnGatewayAggregatedListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -35227,7 +35223,7 @@ impl<'a, C, NC, A> TargetVpnGatewayAggregatedListCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetVpnGatewayAggregatedListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetVpnGatewayAggregatedListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -35265,10 +35261,10 @@ impl<'a, C, NC, A> TargetVpnGatewayAggregatedListCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct TargetVpnGatewayGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetVpnGatewayGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _region: String, _target_vpn_gateway: String, @@ -35277,9 +35273,9 @@ pub struct TargetVpnGatewayGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetVpnGatewayGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetVpnGatewayGetCall<'a, C, A> {} -impl<'a, C, NC, A> TargetVpnGatewayGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetVpnGatewayGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -35413,7 +35409,7 @@ impl<'a, C, NC, A> TargetVpnGatewayGetCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> TargetVpnGatewayGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetVpnGatewayGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -35423,7 +35419,7 @@ impl<'a, C, NC, A> TargetVpnGatewayGetCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The name of the region for this request. - pub fn region(mut self, new_value: &str) -> TargetVpnGatewayGetCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> TargetVpnGatewayGetCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -35433,7 +35429,7 @@ impl<'a, C, NC, A> TargetVpnGatewayGetCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Name of the TargetVpnGateway resource to return. - pub fn target_vpn_gateway(mut self, new_value: &str) -> TargetVpnGatewayGetCall<'a, C, NC, A> { + pub fn target_vpn_gateway(mut self, new_value: &str) -> TargetVpnGatewayGetCall<'a, C, A> { self._target_vpn_gateway = new_value.to_string(); self } @@ -35444,7 +35440,7 @@ impl<'a, C, NC, A> TargetVpnGatewayGetCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetVpnGatewayGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetVpnGatewayGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -35465,7 +35461,7 @@ impl<'a, C, NC, A> TargetVpnGatewayGetCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetVpnGatewayGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetVpnGatewayGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -35482,7 +35478,7 @@ impl<'a, C, NC, A> TargetVpnGatewayGetCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetVpnGatewayGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetVpnGatewayGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -35523,10 +35519,10 @@ impl<'a, C, NC, A> TargetVpnGatewayGetCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct TargetVpnGatewayListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetVpnGatewayListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _region: String, _page_token: Option, @@ -35537,9 +35533,9 @@ pub struct TargetVpnGatewayListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetVpnGatewayListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetVpnGatewayListCall<'a, C, A> {} -impl<'a, C, NC, A> TargetVpnGatewayListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetVpnGatewayListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -35681,7 +35677,7 @@ impl<'a, C, NC, A> TargetVpnGatewayListCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> TargetVpnGatewayListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetVpnGatewayListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -35691,7 +35687,7 @@ impl<'a, C, NC, A> TargetVpnGatewayListCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The name of the region for this request. - pub fn region(mut self, new_value: &str) -> TargetVpnGatewayListCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> TargetVpnGatewayListCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -35699,7 +35695,7 @@ impl<'a, C, NC, A> TargetVpnGatewayListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> TargetVpnGatewayListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TargetVpnGatewayListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -35707,7 +35703,7 @@ impl<'a, C, NC, A> TargetVpnGatewayListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> TargetVpnGatewayListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> TargetVpnGatewayListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -35715,7 +35711,7 @@ impl<'a, C, NC, A> TargetVpnGatewayListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> TargetVpnGatewayListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> TargetVpnGatewayListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -35726,7 +35722,7 @@ impl<'a, C, NC, A> TargetVpnGatewayListCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetVpnGatewayListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetVpnGatewayListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -35747,7 +35743,7 @@ impl<'a, C, NC, A> TargetVpnGatewayListCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetVpnGatewayListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetVpnGatewayListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -35764,7 +35760,7 @@ impl<'a, C, NC, A> TargetVpnGatewayListCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetVpnGatewayListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetVpnGatewayListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -35808,10 +35804,10 @@ impl<'a, C, NC, A> TargetVpnGatewayListCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct TargetVpnGatewayInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetVpnGatewayInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: TargetVpnGateway, _project: String, _region: String, @@ -35820,9 +35816,9 @@ pub struct TargetVpnGatewayInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetVpnGatewayInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetVpnGatewayInsertCall<'a, C, A> {} -impl<'a, C, NC, A> TargetVpnGatewayInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetVpnGatewayInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -35962,7 +35958,7 @@ impl<'a, C, NC, A> TargetVpnGatewayInsertCall<'a, C, NC, A> where NC: hyper::net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &TargetVpnGateway) -> TargetVpnGatewayInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &TargetVpnGateway) -> TargetVpnGatewayInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -35972,7 +35968,7 @@ impl<'a, C, NC, A> TargetVpnGatewayInsertCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> TargetVpnGatewayInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetVpnGatewayInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -35982,7 +35978,7 @@ impl<'a, C, NC, A> TargetVpnGatewayInsertCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The name of the region for this request. - pub fn region(mut self, new_value: &str) -> TargetVpnGatewayInsertCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> TargetVpnGatewayInsertCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -35993,7 +35989,7 @@ impl<'a, C, NC, A> TargetVpnGatewayInsertCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetVpnGatewayInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetVpnGatewayInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -36014,7 +36010,7 @@ impl<'a, C, NC, A> TargetVpnGatewayInsertCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetVpnGatewayInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetVpnGatewayInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -36031,7 +36027,7 @@ impl<'a, C, NC, A> TargetVpnGatewayInsertCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetVpnGatewayInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetVpnGatewayInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -36069,10 +36065,10 @@ impl<'a, C, NC, A> TargetVpnGatewayInsertCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct TargetVpnGatewayDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetVpnGatewayDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _region: String, _target_vpn_gateway: String, @@ -36081,9 +36077,9 @@ pub struct TargetVpnGatewayDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetVpnGatewayDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetVpnGatewayDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> TargetVpnGatewayDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetVpnGatewayDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -36217,7 +36213,7 @@ impl<'a, C, NC, A> TargetVpnGatewayDeleteCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> TargetVpnGatewayDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetVpnGatewayDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -36227,7 +36223,7 @@ impl<'a, C, NC, A> TargetVpnGatewayDeleteCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The name of the region for this request. - pub fn region(mut self, new_value: &str) -> TargetVpnGatewayDeleteCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> TargetVpnGatewayDeleteCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -36237,7 +36233,7 @@ impl<'a, C, NC, A> TargetVpnGatewayDeleteCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Name of the TargetVpnGateway resource to delete. - pub fn target_vpn_gateway(mut self, new_value: &str) -> TargetVpnGatewayDeleteCall<'a, C, NC, A> { + pub fn target_vpn_gateway(mut self, new_value: &str) -> TargetVpnGatewayDeleteCall<'a, C, A> { self._target_vpn_gateway = new_value.to_string(); self } @@ -36248,7 +36244,7 @@ impl<'a, C, NC, A> TargetVpnGatewayDeleteCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetVpnGatewayDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetVpnGatewayDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -36269,7 +36265,7 @@ impl<'a, C, NC, A> TargetVpnGatewayDeleteCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetVpnGatewayDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetVpnGatewayDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -36286,7 +36282,7 @@ impl<'a, C, NC, A> TargetVpnGatewayDeleteCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetVpnGatewayDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetVpnGatewayDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -36330,10 +36326,10 @@ impl<'a, C, NC, A> TargetVpnGatewayDeleteCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct ProjectMoveDiskCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectMoveDiskCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: DiskMoveRequest, _project: String, _delegate: Option<&'a mut Delegate>, @@ -36341,9 +36337,9 @@ pub struct ProjectMoveDiskCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectMoveDiskCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectMoveDiskCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectMoveDiskCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectMoveDiskCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -36482,7 +36478,7 @@ impl<'a, C, NC, A> ProjectMoveDiskCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &DiskMoveRequest) -> ProjectMoveDiskCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &DiskMoveRequest) -> ProjectMoveDiskCall<'a, C, A> { self._request = new_value.clone(); self } @@ -36492,7 +36488,7 @@ impl<'a, C, NC, A> ProjectMoveDiskCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> ProjectMoveDiskCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ProjectMoveDiskCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -36503,7 +36499,7 @@ impl<'a, C, NC, A> ProjectMoveDiskCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectMoveDiskCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectMoveDiskCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -36524,7 +36520,7 @@ impl<'a, C, NC, A> ProjectMoveDiskCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectMoveDiskCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectMoveDiskCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -36541,7 +36537,7 @@ impl<'a, C, NC, A> ProjectMoveDiskCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectMoveDiskCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectMoveDiskCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -36585,10 +36581,10 @@ impl<'a, C, NC, A> ProjectMoveDiskCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct ProjectSetCommonInstanceMetadataCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectSetCommonInstanceMetadataCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: Metadata, _project: String, _delegate: Option<&'a mut Delegate>, @@ -36596,9 +36592,9 @@ pub struct ProjectSetCommonInstanceMetadataCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectSetCommonInstanceMetadataCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectSetCommonInstanceMetadataCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectSetCommonInstanceMetadataCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectSetCommonInstanceMetadataCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -36737,7 +36733,7 @@ impl<'a, C, NC, A> ProjectSetCommonInstanceMetadataCall<'a, C, NC, A> where NC: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Metadata) -> ProjectSetCommonInstanceMetadataCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Metadata) -> ProjectSetCommonInstanceMetadataCall<'a, C, A> { self._request = new_value.clone(); self } @@ -36747,7 +36743,7 @@ impl<'a, C, NC, A> ProjectSetCommonInstanceMetadataCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> ProjectSetCommonInstanceMetadataCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ProjectSetCommonInstanceMetadataCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -36758,7 +36754,7 @@ impl<'a, C, NC, A> ProjectSetCommonInstanceMetadataCall<'a, C, NC, A> where NC: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectSetCommonInstanceMetadataCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectSetCommonInstanceMetadataCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -36779,7 +36775,7 @@ impl<'a, C, NC, A> ProjectSetCommonInstanceMetadataCall<'a, C, NC, A> where NC: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectSetCommonInstanceMetadataCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectSetCommonInstanceMetadataCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -36796,7 +36792,7 @@ impl<'a, C, NC, A> ProjectSetCommonInstanceMetadataCall<'a, C, NC, A> where NC: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectSetCommonInstanceMetadataCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectSetCommonInstanceMetadataCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -36834,19 +36830,19 @@ impl<'a, C, NC, A> ProjectSetCommonInstanceMetadataCall<'a, C, NC, A> where NC: /// .doit(); /// # } /// ``` -pub struct ProjectGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectGetCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -36978,7 +36974,7 @@ impl<'a, C, NC, A> ProjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> ProjectGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ProjectGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -36989,7 +36985,7 @@ impl<'a, C, NC, A> ProjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -37010,7 +37006,7 @@ impl<'a, C, NC, A> ProjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -37027,7 +37023,7 @@ impl<'a, C, NC, A> ProjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -37071,10 +37067,10 @@ impl<'a, C, NC, A> ProjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct ProjectMoveInstanceCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectMoveInstanceCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: InstanceMoveRequest, _project: String, _delegate: Option<&'a mut Delegate>, @@ -37082,9 +37078,9 @@ pub struct ProjectMoveInstanceCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectMoveInstanceCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectMoveInstanceCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectMoveInstanceCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectMoveInstanceCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -37223,7 +37219,7 @@ impl<'a, C, NC, A> ProjectMoveInstanceCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &InstanceMoveRequest) -> ProjectMoveInstanceCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &InstanceMoveRequest) -> ProjectMoveInstanceCall<'a, C, A> { self._request = new_value.clone(); self } @@ -37233,7 +37229,7 @@ impl<'a, C, NC, A> ProjectMoveInstanceCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> ProjectMoveInstanceCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ProjectMoveInstanceCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -37244,7 +37240,7 @@ impl<'a, C, NC, A> ProjectMoveInstanceCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectMoveInstanceCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectMoveInstanceCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -37265,7 +37261,7 @@ impl<'a, C, NC, A> ProjectMoveInstanceCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectMoveInstanceCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectMoveInstanceCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -37282,7 +37278,7 @@ impl<'a, C, NC, A> ProjectMoveInstanceCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectMoveInstanceCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectMoveInstanceCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -37326,10 +37322,10 @@ impl<'a, C, NC, A> ProjectMoveInstanceCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct ProjectSetUsageExportBucketCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectSetUsageExportBucketCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: UsageExportLocation, _project: String, _delegate: Option<&'a mut Delegate>, @@ -37337,9 +37333,9 @@ pub struct ProjectSetUsageExportBucketCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectSetUsageExportBucketCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectSetUsageExportBucketCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectSetUsageExportBucketCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectSetUsageExportBucketCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -37478,7 +37474,7 @@ impl<'a, C, NC, A> ProjectSetUsageExportBucketCall<'a, C, NC, A> where NC: hyper /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &UsageExportLocation) -> ProjectSetUsageExportBucketCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &UsageExportLocation) -> ProjectSetUsageExportBucketCall<'a, C, A> { self._request = new_value.clone(); self } @@ -37488,7 +37484,7 @@ impl<'a, C, NC, A> ProjectSetUsageExportBucketCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> ProjectSetUsageExportBucketCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ProjectSetUsageExportBucketCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -37499,7 +37495,7 @@ impl<'a, C, NC, A> ProjectSetUsageExportBucketCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectSetUsageExportBucketCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectSetUsageExportBucketCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -37520,7 +37516,7 @@ impl<'a, C, NC, A> ProjectSetUsageExportBucketCall<'a, C, NC, A> where NC: hyper /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectSetUsageExportBucketCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectSetUsageExportBucketCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -37537,7 +37533,7 @@ impl<'a, C, NC, A> ProjectSetUsageExportBucketCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectSetUsageExportBucketCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectSetUsageExportBucketCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -37575,10 +37571,10 @@ impl<'a, C, NC, A> ProjectSetUsageExportBucketCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct HttpHealthCheckGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct HttpHealthCheckGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _http_health_check: String, _delegate: Option<&'a mut Delegate>, @@ -37586,9 +37582,9 @@ pub struct HttpHealthCheckGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for HttpHealthCheckGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for HttpHealthCheckGetCall<'a, C, A> {} -impl<'a, C, NC, A> HttpHealthCheckGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> HttpHealthCheckGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -37721,7 +37717,7 @@ impl<'a, C, NC, A> HttpHealthCheckGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> HttpHealthCheckGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> HttpHealthCheckGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -37731,7 +37727,7 @@ impl<'a, C, NC, A> HttpHealthCheckGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Name of the HttpHealthCheck resource to return. - pub fn http_health_check(mut self, new_value: &str) -> HttpHealthCheckGetCall<'a, C, NC, A> { + pub fn http_health_check(mut self, new_value: &str) -> HttpHealthCheckGetCall<'a, C, A> { self._http_health_check = new_value.to_string(); self } @@ -37742,7 +37738,7 @@ impl<'a, C, NC, A> HttpHealthCheckGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> HttpHealthCheckGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> HttpHealthCheckGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -37763,7 +37759,7 @@ impl<'a, C, NC, A> HttpHealthCheckGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> HttpHealthCheckGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> HttpHealthCheckGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -37780,7 +37776,7 @@ impl<'a, C, NC, A> HttpHealthCheckGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> HttpHealthCheckGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> HttpHealthCheckGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -37824,10 +37820,10 @@ impl<'a, C, NC, A> HttpHealthCheckGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct HttpHealthCheckPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct HttpHealthCheckPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: HttpHealthCheck, _project: String, _http_health_check: String, @@ -37836,9 +37832,9 @@ pub struct HttpHealthCheckPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for HttpHealthCheckPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for HttpHealthCheckPatchCall<'a, C, A> {} -impl<'a, C, NC, A> HttpHealthCheckPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> HttpHealthCheckPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -37978,7 +37974,7 @@ impl<'a, C, NC, A> HttpHealthCheckPatchCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &HttpHealthCheck) -> HttpHealthCheckPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &HttpHealthCheck) -> HttpHealthCheckPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -37988,7 +37984,7 @@ impl<'a, C, NC, A> HttpHealthCheckPatchCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> HttpHealthCheckPatchCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> HttpHealthCheckPatchCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -37998,7 +37994,7 @@ impl<'a, C, NC, A> HttpHealthCheckPatchCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Name of the HttpHealthCheck resource to update. - pub fn http_health_check(mut self, new_value: &str) -> HttpHealthCheckPatchCall<'a, C, NC, A> { + pub fn http_health_check(mut self, new_value: &str) -> HttpHealthCheckPatchCall<'a, C, A> { self._http_health_check = new_value.to_string(); self } @@ -38009,7 +38005,7 @@ impl<'a, C, NC, A> HttpHealthCheckPatchCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> HttpHealthCheckPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> HttpHealthCheckPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -38030,7 +38026,7 @@ impl<'a, C, NC, A> HttpHealthCheckPatchCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> HttpHealthCheckPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> HttpHealthCheckPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -38047,7 +38043,7 @@ impl<'a, C, NC, A> HttpHealthCheckPatchCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> HttpHealthCheckPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> HttpHealthCheckPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -38088,10 +38084,10 @@ impl<'a, C, NC, A> HttpHealthCheckPatchCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct HttpHealthCheckListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct HttpHealthCheckListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -38101,9 +38097,9 @@ pub struct HttpHealthCheckListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for HttpHealthCheckListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for HttpHealthCheckListCall<'a, C, A> {} -impl<'a, C, NC, A> HttpHealthCheckListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> HttpHealthCheckListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -38244,7 +38240,7 @@ impl<'a, C, NC, A> HttpHealthCheckListCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> HttpHealthCheckListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> HttpHealthCheckListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -38252,7 +38248,7 @@ impl<'a, C, NC, A> HttpHealthCheckListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> HttpHealthCheckListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> HttpHealthCheckListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -38260,7 +38256,7 @@ impl<'a, C, NC, A> HttpHealthCheckListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> HttpHealthCheckListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> HttpHealthCheckListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -38268,7 +38264,7 @@ impl<'a, C, NC, A> HttpHealthCheckListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> HttpHealthCheckListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> HttpHealthCheckListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -38279,7 +38275,7 @@ impl<'a, C, NC, A> HttpHealthCheckListCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> HttpHealthCheckListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> HttpHealthCheckListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -38300,7 +38296,7 @@ impl<'a, C, NC, A> HttpHealthCheckListCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> HttpHealthCheckListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> HttpHealthCheckListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -38317,7 +38313,7 @@ impl<'a, C, NC, A> HttpHealthCheckListCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> HttpHealthCheckListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> HttpHealthCheckListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -38355,10 +38351,10 @@ impl<'a, C, NC, A> HttpHealthCheckListCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct HttpHealthCheckDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct HttpHealthCheckDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _http_health_check: String, _delegate: Option<&'a mut Delegate>, @@ -38366,9 +38362,9 @@ pub struct HttpHealthCheckDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for HttpHealthCheckDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for HttpHealthCheckDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> HttpHealthCheckDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> HttpHealthCheckDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -38501,7 +38497,7 @@ impl<'a, C, NC, A> HttpHealthCheckDeleteCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> HttpHealthCheckDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> HttpHealthCheckDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -38511,7 +38507,7 @@ impl<'a, C, NC, A> HttpHealthCheckDeleteCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Name of the HttpHealthCheck resource to delete. - pub fn http_health_check(mut self, new_value: &str) -> HttpHealthCheckDeleteCall<'a, C, NC, A> { + pub fn http_health_check(mut self, new_value: &str) -> HttpHealthCheckDeleteCall<'a, C, A> { self._http_health_check = new_value.to_string(); self } @@ -38522,7 +38518,7 @@ impl<'a, C, NC, A> HttpHealthCheckDeleteCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> HttpHealthCheckDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> HttpHealthCheckDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -38543,7 +38539,7 @@ impl<'a, C, NC, A> HttpHealthCheckDeleteCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> HttpHealthCheckDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> HttpHealthCheckDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -38560,7 +38556,7 @@ impl<'a, C, NC, A> HttpHealthCheckDeleteCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> HttpHealthCheckDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> HttpHealthCheckDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -38604,10 +38600,10 @@ impl<'a, C, NC, A> HttpHealthCheckDeleteCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct HttpHealthCheckInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct HttpHealthCheckInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: HttpHealthCheck, _project: String, _delegate: Option<&'a mut Delegate>, @@ -38615,9 +38611,9 @@ pub struct HttpHealthCheckInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for HttpHealthCheckInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for HttpHealthCheckInsertCall<'a, C, A> {} -impl<'a, C, NC, A> HttpHealthCheckInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> HttpHealthCheckInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -38756,7 +38752,7 @@ impl<'a, C, NC, A> HttpHealthCheckInsertCall<'a, C, NC, A> where NC: hyper::net: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &HttpHealthCheck) -> HttpHealthCheckInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &HttpHealthCheck) -> HttpHealthCheckInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -38766,7 +38762,7 @@ impl<'a, C, NC, A> HttpHealthCheckInsertCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> HttpHealthCheckInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> HttpHealthCheckInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -38777,7 +38773,7 @@ impl<'a, C, NC, A> HttpHealthCheckInsertCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> HttpHealthCheckInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> HttpHealthCheckInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -38798,7 +38794,7 @@ impl<'a, C, NC, A> HttpHealthCheckInsertCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> HttpHealthCheckInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> HttpHealthCheckInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -38815,7 +38811,7 @@ impl<'a, C, NC, A> HttpHealthCheckInsertCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> HttpHealthCheckInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> HttpHealthCheckInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -38859,10 +38855,10 @@ impl<'a, C, NC, A> HttpHealthCheckInsertCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct HttpHealthCheckUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct HttpHealthCheckUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: HttpHealthCheck, _project: String, _http_health_check: String, @@ -38871,9 +38867,9 @@ pub struct HttpHealthCheckUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for HttpHealthCheckUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for HttpHealthCheckUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> HttpHealthCheckUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> HttpHealthCheckUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -39013,7 +39009,7 @@ impl<'a, C, NC, A> HttpHealthCheckUpdateCall<'a, C, NC, A> where NC: hyper::net: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &HttpHealthCheck) -> HttpHealthCheckUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &HttpHealthCheck) -> HttpHealthCheckUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -39023,7 +39019,7 @@ impl<'a, C, NC, A> HttpHealthCheckUpdateCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> HttpHealthCheckUpdateCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> HttpHealthCheckUpdateCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -39033,7 +39029,7 @@ impl<'a, C, NC, A> HttpHealthCheckUpdateCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Name of the HttpHealthCheck resource to update. - pub fn http_health_check(mut self, new_value: &str) -> HttpHealthCheckUpdateCall<'a, C, NC, A> { + pub fn http_health_check(mut self, new_value: &str) -> HttpHealthCheckUpdateCall<'a, C, A> { self._http_health_check = new_value.to_string(); self } @@ -39044,7 +39040,7 @@ impl<'a, C, NC, A> HttpHealthCheckUpdateCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> HttpHealthCheckUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> HttpHealthCheckUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -39065,7 +39061,7 @@ impl<'a, C, NC, A> HttpHealthCheckUpdateCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> HttpHealthCheckUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> HttpHealthCheckUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -39082,7 +39078,7 @@ impl<'a, C, NC, A> HttpHealthCheckUpdateCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> HttpHealthCheckUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> HttpHealthCheckUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -39120,10 +39116,10 @@ impl<'a, C, NC, A> HttpHealthCheckUpdateCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct InstanceTemplateDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceTemplateDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _instance_template: String, _delegate: Option<&'a mut Delegate>, @@ -39131,9 +39127,9 @@ pub struct InstanceTemplateDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceTemplateDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceTemplateDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceTemplateDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceTemplateDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -39266,7 +39262,7 @@ impl<'a, C, NC, A> InstanceTemplateDeleteCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> InstanceTemplateDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceTemplateDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -39276,7 +39272,7 @@ impl<'a, C, NC, A> InstanceTemplateDeleteCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Name of the instance template resource to delete. - pub fn instance_template(mut self, new_value: &str) -> InstanceTemplateDeleteCall<'a, C, NC, A> { + pub fn instance_template(mut self, new_value: &str) -> InstanceTemplateDeleteCall<'a, C, A> { self._instance_template = new_value.to_string(); self } @@ -39287,7 +39283,7 @@ impl<'a, C, NC, A> InstanceTemplateDeleteCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceTemplateDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceTemplateDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -39308,7 +39304,7 @@ impl<'a, C, NC, A> InstanceTemplateDeleteCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceTemplateDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceTemplateDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -39325,7 +39321,7 @@ impl<'a, C, NC, A> InstanceTemplateDeleteCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceTemplateDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceTemplateDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -39363,10 +39359,10 @@ impl<'a, C, NC, A> InstanceTemplateDeleteCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct InstanceTemplateGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceTemplateGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _instance_template: String, _delegate: Option<&'a mut Delegate>, @@ -39374,9 +39370,9 @@ pub struct InstanceTemplateGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceTemplateGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceTemplateGetCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceTemplateGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceTemplateGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -39509,7 +39505,7 @@ impl<'a, C, NC, A> InstanceTemplateGetCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> InstanceTemplateGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceTemplateGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -39519,7 +39515,7 @@ impl<'a, C, NC, A> InstanceTemplateGetCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Name of the instance template resource to return. - pub fn instance_template(mut self, new_value: &str) -> InstanceTemplateGetCall<'a, C, NC, A> { + pub fn instance_template(mut self, new_value: &str) -> InstanceTemplateGetCall<'a, C, A> { self._instance_template = new_value.to_string(); self } @@ -39530,7 +39526,7 @@ impl<'a, C, NC, A> InstanceTemplateGetCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceTemplateGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceTemplateGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -39551,7 +39547,7 @@ impl<'a, C, NC, A> InstanceTemplateGetCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceTemplateGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceTemplateGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -39568,7 +39564,7 @@ impl<'a, C, NC, A> InstanceTemplateGetCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceTemplateGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceTemplateGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -39609,10 +39605,10 @@ impl<'a, C, NC, A> InstanceTemplateGetCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct InstanceTemplateListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceTemplateListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -39622,9 +39618,9 @@ pub struct InstanceTemplateListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceTemplateListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceTemplateListCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceTemplateListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceTemplateListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -39765,7 +39761,7 @@ impl<'a, C, NC, A> InstanceTemplateListCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> InstanceTemplateListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceTemplateListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -39773,7 +39769,7 @@ impl<'a, C, NC, A> InstanceTemplateListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> InstanceTemplateListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> InstanceTemplateListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -39781,7 +39777,7 @@ impl<'a, C, NC, A> InstanceTemplateListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> InstanceTemplateListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> InstanceTemplateListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -39789,7 +39785,7 @@ impl<'a, C, NC, A> InstanceTemplateListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> InstanceTemplateListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> InstanceTemplateListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -39800,7 +39796,7 @@ impl<'a, C, NC, A> InstanceTemplateListCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceTemplateListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceTemplateListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -39821,7 +39817,7 @@ impl<'a, C, NC, A> InstanceTemplateListCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceTemplateListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceTemplateListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -39838,7 +39834,7 @@ impl<'a, C, NC, A> InstanceTemplateListCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceTemplateListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceTemplateListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -39882,10 +39878,10 @@ impl<'a, C, NC, A> InstanceTemplateListCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct InstanceTemplateInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceTemplateInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: InstanceTemplate, _project: String, _delegate: Option<&'a mut Delegate>, @@ -39893,9 +39889,9 @@ pub struct InstanceTemplateInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceTemplateInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceTemplateInsertCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceTemplateInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceTemplateInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -40034,7 +40030,7 @@ impl<'a, C, NC, A> InstanceTemplateInsertCall<'a, C, NC, A> where NC: hyper::net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &InstanceTemplate) -> InstanceTemplateInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &InstanceTemplate) -> InstanceTemplateInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -40044,7 +40040,7 @@ impl<'a, C, NC, A> InstanceTemplateInsertCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> InstanceTemplateInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceTemplateInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -40055,7 +40051,7 @@ impl<'a, C, NC, A> InstanceTemplateInsertCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceTemplateInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceTemplateInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -40076,7 +40072,7 @@ impl<'a, C, NC, A> InstanceTemplateInsertCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceTemplateInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceTemplateInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -40093,7 +40089,7 @@ impl<'a, C, NC, A> InstanceTemplateInsertCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceTemplateInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceTemplateInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -40131,10 +40127,10 @@ impl<'a, C, NC, A> InstanceTemplateInsertCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct TargetHttpProxyDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetHttpProxyDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _target_http_proxy: String, _delegate: Option<&'a mut Delegate>, @@ -40142,9 +40138,9 @@ pub struct TargetHttpProxyDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetHttpProxyDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetHttpProxyDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> TargetHttpProxyDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetHttpProxyDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -40277,7 +40273,7 @@ impl<'a, C, NC, A> TargetHttpProxyDeleteCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> TargetHttpProxyDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetHttpProxyDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -40287,7 +40283,7 @@ impl<'a, C, NC, A> TargetHttpProxyDeleteCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Name of the TargetHttpProxy resource to delete. - pub fn target_http_proxy(mut self, new_value: &str) -> TargetHttpProxyDeleteCall<'a, C, NC, A> { + pub fn target_http_proxy(mut self, new_value: &str) -> TargetHttpProxyDeleteCall<'a, C, A> { self._target_http_proxy = new_value.to_string(); self } @@ -40298,7 +40294,7 @@ impl<'a, C, NC, A> TargetHttpProxyDeleteCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetHttpProxyDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetHttpProxyDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -40319,7 +40315,7 @@ impl<'a, C, NC, A> TargetHttpProxyDeleteCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetHttpProxyDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetHttpProxyDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -40336,7 +40332,7 @@ impl<'a, C, NC, A> TargetHttpProxyDeleteCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetHttpProxyDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetHttpProxyDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -40377,10 +40373,10 @@ impl<'a, C, NC, A> TargetHttpProxyDeleteCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct TargetHttpProxyListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetHttpProxyListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -40390,9 +40386,9 @@ pub struct TargetHttpProxyListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetHttpProxyListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetHttpProxyListCall<'a, C, A> {} -impl<'a, C, NC, A> TargetHttpProxyListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetHttpProxyListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -40533,7 +40529,7 @@ impl<'a, C, NC, A> TargetHttpProxyListCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> TargetHttpProxyListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetHttpProxyListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -40541,7 +40537,7 @@ impl<'a, C, NC, A> TargetHttpProxyListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> TargetHttpProxyListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TargetHttpProxyListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -40549,7 +40545,7 @@ impl<'a, C, NC, A> TargetHttpProxyListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> TargetHttpProxyListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> TargetHttpProxyListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -40557,7 +40553,7 @@ impl<'a, C, NC, A> TargetHttpProxyListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> TargetHttpProxyListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> TargetHttpProxyListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -40568,7 +40564,7 @@ impl<'a, C, NC, A> TargetHttpProxyListCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetHttpProxyListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetHttpProxyListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -40589,7 +40585,7 @@ impl<'a, C, NC, A> TargetHttpProxyListCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetHttpProxyListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetHttpProxyListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -40606,7 +40602,7 @@ impl<'a, C, NC, A> TargetHttpProxyListCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetHttpProxyListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetHttpProxyListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -40644,10 +40640,10 @@ impl<'a, C, NC, A> TargetHttpProxyListCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct TargetHttpProxyGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetHttpProxyGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _target_http_proxy: String, _delegate: Option<&'a mut Delegate>, @@ -40655,9 +40651,9 @@ pub struct TargetHttpProxyGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetHttpProxyGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetHttpProxyGetCall<'a, C, A> {} -impl<'a, C, NC, A> TargetHttpProxyGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetHttpProxyGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -40790,7 +40786,7 @@ impl<'a, C, NC, A> TargetHttpProxyGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> TargetHttpProxyGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetHttpProxyGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -40800,7 +40796,7 @@ impl<'a, C, NC, A> TargetHttpProxyGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Name of the TargetHttpProxy resource to return. - pub fn target_http_proxy(mut self, new_value: &str) -> TargetHttpProxyGetCall<'a, C, NC, A> { + pub fn target_http_proxy(mut self, new_value: &str) -> TargetHttpProxyGetCall<'a, C, A> { self._target_http_proxy = new_value.to_string(); self } @@ -40811,7 +40807,7 @@ impl<'a, C, NC, A> TargetHttpProxyGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetHttpProxyGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetHttpProxyGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -40832,7 +40828,7 @@ impl<'a, C, NC, A> TargetHttpProxyGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetHttpProxyGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetHttpProxyGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -40849,7 +40845,7 @@ impl<'a, C, NC, A> TargetHttpProxyGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetHttpProxyGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetHttpProxyGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -40893,10 +40889,10 @@ impl<'a, C, NC, A> TargetHttpProxyGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct TargetHttpProxySetUrlMapCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetHttpProxySetUrlMapCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: UrlMapReference, _project: String, _target_http_proxy: String, @@ -40905,9 +40901,9 @@ pub struct TargetHttpProxySetUrlMapCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetHttpProxySetUrlMapCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetHttpProxySetUrlMapCall<'a, C, A> {} -impl<'a, C, NC, A> TargetHttpProxySetUrlMapCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetHttpProxySetUrlMapCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -41047,7 +41043,7 @@ impl<'a, C, NC, A> TargetHttpProxySetUrlMapCall<'a, C, NC, A> where NC: hyper::n /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &UrlMapReference) -> TargetHttpProxySetUrlMapCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &UrlMapReference) -> TargetHttpProxySetUrlMapCall<'a, C, A> { self._request = new_value.clone(); self } @@ -41057,7 +41053,7 @@ impl<'a, C, NC, A> TargetHttpProxySetUrlMapCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> TargetHttpProxySetUrlMapCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetHttpProxySetUrlMapCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -41067,7 +41063,7 @@ impl<'a, C, NC, A> TargetHttpProxySetUrlMapCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Name of the TargetHttpProxy resource whose URL map is to be set. - pub fn target_http_proxy(mut self, new_value: &str) -> TargetHttpProxySetUrlMapCall<'a, C, NC, A> { + pub fn target_http_proxy(mut self, new_value: &str) -> TargetHttpProxySetUrlMapCall<'a, C, A> { self._target_http_proxy = new_value.to_string(); self } @@ -41078,7 +41074,7 @@ impl<'a, C, NC, A> TargetHttpProxySetUrlMapCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetHttpProxySetUrlMapCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetHttpProxySetUrlMapCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -41099,7 +41095,7 @@ impl<'a, C, NC, A> TargetHttpProxySetUrlMapCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetHttpProxySetUrlMapCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetHttpProxySetUrlMapCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -41116,7 +41112,7 @@ impl<'a, C, NC, A> TargetHttpProxySetUrlMapCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetHttpProxySetUrlMapCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetHttpProxySetUrlMapCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -41160,10 +41156,10 @@ impl<'a, C, NC, A> TargetHttpProxySetUrlMapCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct TargetHttpProxyInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TargetHttpProxyInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: TargetHttpProxy, _project: String, _delegate: Option<&'a mut Delegate>, @@ -41171,9 +41167,9 @@ pub struct TargetHttpProxyInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TargetHttpProxyInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TargetHttpProxyInsertCall<'a, C, A> {} -impl<'a, C, NC, A> TargetHttpProxyInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TargetHttpProxyInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -41312,7 +41308,7 @@ impl<'a, C, NC, A> TargetHttpProxyInsertCall<'a, C, NC, A> where NC: hyper::net: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &TargetHttpProxy) -> TargetHttpProxyInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &TargetHttpProxy) -> TargetHttpProxyInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -41322,7 +41318,7 @@ impl<'a, C, NC, A> TargetHttpProxyInsertCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> TargetHttpProxyInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TargetHttpProxyInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -41333,7 +41329,7 @@ impl<'a, C, NC, A> TargetHttpProxyInsertCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetHttpProxyInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TargetHttpProxyInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -41354,7 +41350,7 @@ impl<'a, C, NC, A> TargetHttpProxyInsertCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TargetHttpProxyInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TargetHttpProxyInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -41371,7 +41367,7 @@ impl<'a, C, NC, A> TargetHttpProxyInsertCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TargetHttpProxyInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TargetHttpProxyInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -41409,10 +41405,10 @@ impl<'a, C, NC, A> TargetHttpProxyInsertCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct ZoneOperationDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneOperationDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _operation: String, @@ -41421,9 +41417,9 @@ pub struct ZoneOperationDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ZoneOperationDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ZoneOperationDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ZoneOperationDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ZoneOperationDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -41546,7 +41542,7 @@ impl<'a, C, NC, A> ZoneOperationDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> ZoneOperationDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ZoneOperationDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -41556,7 +41552,7 @@ impl<'a, C, NC, A> ZoneOperationDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Name of the zone scoping this request. - pub fn zone(mut self, new_value: &str) -> ZoneOperationDeleteCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> ZoneOperationDeleteCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -41566,7 +41562,7 @@ impl<'a, C, NC, A> ZoneOperationDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Name of the operation resource to delete. - pub fn operation(mut self, new_value: &str) -> ZoneOperationDeleteCall<'a, C, NC, A> { + pub fn operation(mut self, new_value: &str) -> ZoneOperationDeleteCall<'a, C, A> { self._operation = new_value.to_string(); self } @@ -41577,7 +41573,7 @@ impl<'a, C, NC, A> ZoneOperationDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneOperationDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneOperationDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -41598,7 +41594,7 @@ impl<'a, C, NC, A> ZoneOperationDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ZoneOperationDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ZoneOperationDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -41615,7 +41611,7 @@ impl<'a, C, NC, A> ZoneOperationDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ZoneOperationDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ZoneOperationDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -41656,10 +41652,10 @@ impl<'a, C, NC, A> ZoneOperationDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct ZoneOperationListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneOperationListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _page_token: Option, @@ -41670,9 +41666,9 @@ pub struct ZoneOperationListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ZoneOperationListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ZoneOperationListCall<'a, C, A> {} -impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ZoneOperationListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -41814,7 +41810,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -41824,7 +41820,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Name of the zone scoping this request. - pub fn zone(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -41832,7 +41828,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -41840,7 +41836,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> ZoneOperationListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -41848,7 +41844,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -41859,7 +41855,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneOperationListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -41880,7 +41876,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ZoneOperationListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ZoneOperationListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -41897,7 +41893,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ZoneOperationListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ZoneOperationListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -41935,10 +41931,10 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct ZoneOperationGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneOperationGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _zone: String, _operation: String, @@ -41947,9 +41943,9 @@ pub struct ZoneOperationGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ZoneOperationGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ZoneOperationGetCall<'a, C, A> {} -impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ZoneOperationGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -42083,7 +42079,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -42093,7 +42089,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Name of the zone scoping this request. - pub fn zone(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -42103,7 +42099,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Name of the operation resource to return. - pub fn operation(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn operation(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, A> { self._operation = new_value.to_string(); self } @@ -42114,7 +42110,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneOperationGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -42135,7 +42131,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ZoneOperationGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ZoneOperationGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -42152,7 +42148,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ZoneOperationGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ZoneOperationGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -42190,10 +42186,10 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct RouteGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RouteGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _route: String, _delegate: Option<&'a mut Delegate>, @@ -42201,9 +42197,9 @@ pub struct RouteGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RouteGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RouteGetCall<'a, C, A> {} -impl<'a, C, NC, A> RouteGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RouteGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -42336,7 +42332,7 @@ impl<'a, C, NC, A> RouteGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> RouteGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> RouteGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -42346,7 +42342,7 @@ impl<'a, C, NC, A> RouteGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Name of the route resource to return. - pub fn route(mut self, new_value: &str) -> RouteGetCall<'a, C, NC, A> { + pub fn route(mut self, new_value: &str) -> RouteGetCall<'a, C, A> { self._route = new_value.to_string(); self } @@ -42357,7 +42353,7 @@ impl<'a, C, NC, A> RouteGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RouteGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RouteGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -42378,7 +42374,7 @@ impl<'a, C, NC, A> RouteGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RouteGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RouteGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -42395,7 +42391,7 @@ impl<'a, C, NC, A> RouteGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RouteGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RouteGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -42439,10 +42435,10 @@ impl<'a, C, NC, A> RouteGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct RouteInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RouteInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: Route, _project: String, _delegate: Option<&'a mut Delegate>, @@ -42450,9 +42446,9 @@ pub struct RouteInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RouteInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RouteInsertCall<'a, C, A> {} -impl<'a, C, NC, A> RouteInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RouteInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -42591,7 +42587,7 @@ impl<'a, C, NC, A> RouteInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Route) -> RouteInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Route) -> RouteInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -42601,7 +42597,7 @@ impl<'a, C, NC, A> RouteInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> RouteInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> RouteInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -42612,7 +42608,7 @@ impl<'a, C, NC, A> RouteInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RouteInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RouteInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -42633,7 +42629,7 @@ impl<'a, C, NC, A> RouteInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RouteInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RouteInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -42650,7 +42646,7 @@ impl<'a, C, NC, A> RouteInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RouteInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RouteInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -42691,10 +42687,10 @@ impl<'a, C, NC, A> RouteInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct RouteListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RouteListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -42704,9 +42700,9 @@ pub struct RouteListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RouteListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RouteListCall<'a, C, A> {} -impl<'a, C, NC, A> RouteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RouteListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -42847,7 +42843,7 @@ impl<'a, C, NC, A> RouteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> RouteListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> RouteListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -42855,7 +42851,7 @@ impl<'a, C, NC, A> RouteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> RouteListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> RouteListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -42863,7 +42859,7 @@ impl<'a, C, NC, A> RouteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> RouteListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> RouteListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -42871,7 +42867,7 @@ impl<'a, C, NC, A> RouteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> RouteListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> RouteListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -42882,7 +42878,7 @@ impl<'a, C, NC, A> RouteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RouteListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RouteListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -42903,7 +42899,7 @@ impl<'a, C, NC, A> RouteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RouteListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RouteListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -42920,7 +42916,7 @@ impl<'a, C, NC, A> RouteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RouteListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RouteListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -42958,10 +42954,10 @@ impl<'a, C, NC, A> RouteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct RouteDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RouteDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _route: String, _delegate: Option<&'a mut Delegate>, @@ -42969,9 +42965,9 @@ pub struct RouteDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RouteDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RouteDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> RouteDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RouteDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -43104,7 +43100,7 @@ impl<'a, C, NC, A> RouteDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> RouteDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> RouteDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -43114,7 +43110,7 @@ impl<'a, C, NC, A> RouteDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Name of the route resource to delete. - pub fn route(mut self, new_value: &str) -> RouteDeleteCall<'a, C, NC, A> { + pub fn route(mut self, new_value: &str) -> RouteDeleteCall<'a, C, A> { self._route = new_value.to_string(); self } @@ -43125,7 +43121,7 @@ impl<'a, C, NC, A> RouteDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RouteDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RouteDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -43146,7 +43142,7 @@ impl<'a, C, NC, A> RouteDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RouteDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RouteDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -43163,7 +43159,7 @@ impl<'a, C, NC, A> RouteDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RouteDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RouteDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -43207,10 +43203,10 @@ impl<'a, C, NC, A> RouteDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct FirewallPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FirewallPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: Firewall, _project: String, _firewall: String, @@ -43219,9 +43215,9 @@ pub struct FirewallPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FirewallPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FirewallPatchCall<'a, C, A> {} -impl<'a, C, NC, A> FirewallPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FirewallPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -43361,7 +43357,7 @@ impl<'a, C, NC, A> FirewallPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Firewall) -> FirewallPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Firewall) -> FirewallPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -43371,7 +43367,7 @@ impl<'a, C, NC, A> FirewallPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> FirewallPatchCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> FirewallPatchCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -43381,7 +43377,7 @@ impl<'a, C, NC, A> FirewallPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Name of the firewall resource to update. - pub fn firewall(mut self, new_value: &str) -> FirewallPatchCall<'a, C, NC, A> { + pub fn firewall(mut self, new_value: &str) -> FirewallPatchCall<'a, C, A> { self._firewall = new_value.to_string(); self } @@ -43392,7 +43388,7 @@ impl<'a, C, NC, A> FirewallPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FirewallPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FirewallPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -43413,7 +43409,7 @@ impl<'a, C, NC, A> FirewallPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FirewallPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FirewallPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -43430,7 +43426,7 @@ impl<'a, C, NC, A> FirewallPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FirewallPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FirewallPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -43468,10 +43464,10 @@ impl<'a, C, NC, A> FirewallPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct FirewallGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FirewallGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _firewall: String, _delegate: Option<&'a mut Delegate>, @@ -43479,9 +43475,9 @@ pub struct FirewallGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FirewallGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FirewallGetCall<'a, C, A> {} -impl<'a, C, NC, A> FirewallGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FirewallGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -43614,7 +43610,7 @@ impl<'a, C, NC, A> FirewallGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> FirewallGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> FirewallGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -43624,7 +43620,7 @@ impl<'a, C, NC, A> FirewallGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Name of the firewall resource to return. - pub fn firewall(mut self, new_value: &str) -> FirewallGetCall<'a, C, NC, A> { + pub fn firewall(mut self, new_value: &str) -> FirewallGetCall<'a, C, A> { self._firewall = new_value.to_string(); self } @@ -43635,7 +43631,7 @@ impl<'a, C, NC, A> FirewallGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FirewallGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FirewallGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -43656,7 +43652,7 @@ impl<'a, C, NC, A> FirewallGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FirewallGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FirewallGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -43673,7 +43669,7 @@ impl<'a, C, NC, A> FirewallGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FirewallGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FirewallGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -43717,10 +43713,10 @@ impl<'a, C, NC, A> FirewallGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct FirewallInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FirewallInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: Firewall, _project: String, _delegate: Option<&'a mut Delegate>, @@ -43728,9 +43724,9 @@ pub struct FirewallInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FirewallInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FirewallInsertCall<'a, C, A> {} -impl<'a, C, NC, A> FirewallInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FirewallInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -43869,7 +43865,7 @@ impl<'a, C, NC, A> FirewallInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Firewall) -> FirewallInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Firewall) -> FirewallInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -43879,7 +43875,7 @@ impl<'a, C, NC, A> FirewallInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> FirewallInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> FirewallInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -43890,7 +43886,7 @@ impl<'a, C, NC, A> FirewallInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FirewallInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FirewallInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -43911,7 +43907,7 @@ impl<'a, C, NC, A> FirewallInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FirewallInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FirewallInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -43928,7 +43924,7 @@ impl<'a, C, NC, A> FirewallInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FirewallInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FirewallInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -43972,10 +43968,10 @@ impl<'a, C, NC, A> FirewallInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct FirewallUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FirewallUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: Firewall, _project: String, _firewall: String, @@ -43984,9 +43980,9 @@ pub struct FirewallUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FirewallUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FirewallUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> FirewallUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FirewallUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -44126,7 +44122,7 @@ impl<'a, C, NC, A> FirewallUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Firewall) -> FirewallUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Firewall) -> FirewallUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -44136,7 +44132,7 @@ impl<'a, C, NC, A> FirewallUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> FirewallUpdateCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> FirewallUpdateCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -44146,7 +44142,7 @@ impl<'a, C, NC, A> FirewallUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Name of the firewall resource to update. - pub fn firewall(mut self, new_value: &str) -> FirewallUpdateCall<'a, C, NC, A> { + pub fn firewall(mut self, new_value: &str) -> FirewallUpdateCall<'a, C, A> { self._firewall = new_value.to_string(); self } @@ -44157,7 +44153,7 @@ impl<'a, C, NC, A> FirewallUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FirewallUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FirewallUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -44178,7 +44174,7 @@ impl<'a, C, NC, A> FirewallUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FirewallUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FirewallUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -44195,7 +44191,7 @@ impl<'a, C, NC, A> FirewallUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FirewallUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FirewallUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -44233,10 +44229,10 @@ impl<'a, C, NC, A> FirewallUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct FirewallDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FirewallDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _firewall: String, _delegate: Option<&'a mut Delegate>, @@ -44244,9 +44240,9 @@ pub struct FirewallDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FirewallDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FirewallDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> FirewallDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FirewallDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -44379,7 +44375,7 @@ impl<'a, C, NC, A> FirewallDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> FirewallDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> FirewallDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -44389,7 +44385,7 @@ impl<'a, C, NC, A> FirewallDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Name of the firewall resource to delete. - pub fn firewall(mut self, new_value: &str) -> FirewallDeleteCall<'a, C, NC, A> { + pub fn firewall(mut self, new_value: &str) -> FirewallDeleteCall<'a, C, A> { self._firewall = new_value.to_string(); self } @@ -44400,7 +44396,7 @@ impl<'a, C, NC, A> FirewallDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FirewallDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FirewallDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -44421,7 +44417,7 @@ impl<'a, C, NC, A> FirewallDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FirewallDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FirewallDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -44438,7 +44434,7 @@ impl<'a, C, NC, A> FirewallDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FirewallDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FirewallDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -44479,10 +44475,10 @@ impl<'a, C, NC, A> FirewallDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct FirewallListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FirewallListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -44492,9 +44488,9 @@ pub struct FirewallListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FirewallListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FirewallListCall<'a, C, A> {} -impl<'a, C, NC, A> FirewallListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FirewallListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -44635,7 +44631,7 @@ impl<'a, C, NC, A> FirewallListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> FirewallListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> FirewallListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -44643,7 +44639,7 @@ impl<'a, C, NC, A> FirewallListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> FirewallListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> FirewallListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -44651,7 +44647,7 @@ impl<'a, C, NC, A> FirewallListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> FirewallListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> FirewallListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -44659,7 +44655,7 @@ impl<'a, C, NC, A> FirewallListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> FirewallListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> FirewallListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -44670,7 +44666,7 @@ impl<'a, C, NC, A> FirewallListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FirewallListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FirewallListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -44691,7 +44687,7 @@ impl<'a, C, NC, A> FirewallListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FirewallListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FirewallListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -44708,7 +44704,7 @@ impl<'a, C, NC, A> FirewallListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FirewallListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FirewallListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -44746,10 +44742,10 @@ impl<'a, C, NC, A> FirewallListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct VpnTunnelDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VpnTunnelDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _region: String, _vpn_tunnel: String, @@ -44758,9 +44754,9 @@ pub struct VpnTunnelDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VpnTunnelDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VpnTunnelDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> VpnTunnelDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VpnTunnelDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -44894,7 +44890,7 @@ impl<'a, C, NC, A> VpnTunnelDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> VpnTunnelDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> VpnTunnelDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -44904,7 +44900,7 @@ impl<'a, C, NC, A> VpnTunnelDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The name of the region for this request. - pub fn region(mut self, new_value: &str) -> VpnTunnelDeleteCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> VpnTunnelDeleteCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -44914,7 +44910,7 @@ impl<'a, C, NC, A> VpnTunnelDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Name of the VpnTunnel resource to delete. - pub fn vpn_tunnel(mut self, new_value: &str) -> VpnTunnelDeleteCall<'a, C, NC, A> { + pub fn vpn_tunnel(mut self, new_value: &str) -> VpnTunnelDeleteCall<'a, C, A> { self._vpn_tunnel = new_value.to_string(); self } @@ -44925,7 +44921,7 @@ impl<'a, C, NC, A> VpnTunnelDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VpnTunnelDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VpnTunnelDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -44946,7 +44942,7 @@ impl<'a, C, NC, A> VpnTunnelDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VpnTunnelDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VpnTunnelDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -44963,7 +44959,7 @@ impl<'a, C, NC, A> VpnTunnelDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VpnTunnelDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VpnTunnelDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -45004,10 +45000,10 @@ impl<'a, C, NC, A> VpnTunnelDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct VpnTunnelListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VpnTunnelListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _region: String, _page_token: Option, @@ -45018,9 +45014,9 @@ pub struct VpnTunnelListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VpnTunnelListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VpnTunnelListCall<'a, C, A> {} -impl<'a, C, NC, A> VpnTunnelListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VpnTunnelListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -45162,7 +45158,7 @@ impl<'a, C, NC, A> VpnTunnelListCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> VpnTunnelListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> VpnTunnelListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -45172,7 +45168,7 @@ impl<'a, C, NC, A> VpnTunnelListCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The name of the region for this request. - pub fn region(mut self, new_value: &str) -> VpnTunnelListCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> VpnTunnelListCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -45180,7 +45176,7 @@ impl<'a, C, NC, A> VpnTunnelListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> VpnTunnelListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> VpnTunnelListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -45188,7 +45184,7 @@ impl<'a, C, NC, A> VpnTunnelListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> VpnTunnelListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> VpnTunnelListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -45196,7 +45192,7 @@ impl<'a, C, NC, A> VpnTunnelListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> VpnTunnelListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> VpnTunnelListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -45207,7 +45203,7 @@ impl<'a, C, NC, A> VpnTunnelListCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VpnTunnelListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VpnTunnelListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -45228,7 +45224,7 @@ impl<'a, C, NC, A> VpnTunnelListCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VpnTunnelListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VpnTunnelListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -45245,7 +45241,7 @@ impl<'a, C, NC, A> VpnTunnelListCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VpnTunnelListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VpnTunnelListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -45283,10 +45279,10 @@ impl<'a, C, NC, A> VpnTunnelListCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct VpnTunnelGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VpnTunnelGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _region: String, _vpn_tunnel: String, @@ -45295,9 +45291,9 @@ pub struct VpnTunnelGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VpnTunnelGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VpnTunnelGetCall<'a, C, A> {} -impl<'a, C, NC, A> VpnTunnelGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VpnTunnelGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -45431,7 +45427,7 @@ impl<'a, C, NC, A> VpnTunnelGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> VpnTunnelGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> VpnTunnelGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -45441,7 +45437,7 @@ impl<'a, C, NC, A> VpnTunnelGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The name of the region for this request. - pub fn region(mut self, new_value: &str) -> VpnTunnelGetCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> VpnTunnelGetCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -45451,7 +45447,7 @@ impl<'a, C, NC, A> VpnTunnelGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Name of the VpnTunnel resource to return. - pub fn vpn_tunnel(mut self, new_value: &str) -> VpnTunnelGetCall<'a, C, NC, A> { + pub fn vpn_tunnel(mut self, new_value: &str) -> VpnTunnelGetCall<'a, C, A> { self._vpn_tunnel = new_value.to_string(); self } @@ -45462,7 +45458,7 @@ impl<'a, C, NC, A> VpnTunnelGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VpnTunnelGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VpnTunnelGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -45483,7 +45479,7 @@ impl<'a, C, NC, A> VpnTunnelGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VpnTunnelGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VpnTunnelGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -45500,7 +45496,7 @@ impl<'a, C, NC, A> VpnTunnelGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VpnTunnelGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VpnTunnelGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -45544,10 +45540,10 @@ impl<'a, C, NC, A> VpnTunnelGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct VpnTunnelInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VpnTunnelInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _request: VpnTunnel, _project: String, _region: String, @@ -45556,9 +45552,9 @@ pub struct VpnTunnelInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VpnTunnelInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VpnTunnelInsertCall<'a, C, A> {} -impl<'a, C, NC, A> VpnTunnelInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VpnTunnelInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -45698,7 +45694,7 @@ impl<'a, C, NC, A> VpnTunnelInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &VpnTunnel) -> VpnTunnelInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &VpnTunnel) -> VpnTunnelInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -45708,7 +45704,7 @@ impl<'a, C, NC, A> VpnTunnelInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> VpnTunnelInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> VpnTunnelInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -45718,7 +45714,7 @@ impl<'a, C, NC, A> VpnTunnelInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The name of the region for this request. - pub fn region(mut self, new_value: &str) -> VpnTunnelInsertCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> VpnTunnelInsertCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -45729,7 +45725,7 @@ impl<'a, C, NC, A> VpnTunnelInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VpnTunnelInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VpnTunnelInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -45750,7 +45746,7 @@ impl<'a, C, NC, A> VpnTunnelInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VpnTunnelInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VpnTunnelInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -45767,7 +45763,7 @@ impl<'a, C, NC, A> VpnTunnelInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VpnTunnelInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VpnTunnelInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -45808,10 +45804,10 @@ impl<'a, C, NC, A> VpnTunnelInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct VpnTunnelAggregatedListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VpnTunnelAggregatedListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _page_token: Option, _max_results: Option, @@ -45821,9 +45817,9 @@ pub struct VpnTunnelAggregatedListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VpnTunnelAggregatedListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VpnTunnelAggregatedListCall<'a, C, A> {} -impl<'a, C, NC, A> VpnTunnelAggregatedListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VpnTunnelAggregatedListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -45964,7 +45960,7 @@ impl<'a, C, NC, A> VpnTunnelAggregatedListCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> VpnTunnelAggregatedListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> VpnTunnelAggregatedListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -45972,7 +45968,7 @@ impl<'a, C, NC, A> VpnTunnelAggregatedListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> VpnTunnelAggregatedListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> VpnTunnelAggregatedListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -45980,7 +45976,7 @@ impl<'a, C, NC, A> VpnTunnelAggregatedListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> VpnTunnelAggregatedListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> VpnTunnelAggregatedListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -45988,7 +45984,7 @@ impl<'a, C, NC, A> VpnTunnelAggregatedListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> VpnTunnelAggregatedListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> VpnTunnelAggregatedListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -45999,7 +45995,7 @@ impl<'a, C, NC, A> VpnTunnelAggregatedListCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VpnTunnelAggregatedListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VpnTunnelAggregatedListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -46020,7 +46016,7 @@ impl<'a, C, NC, A> VpnTunnelAggregatedListCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VpnTunnelAggregatedListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VpnTunnelAggregatedListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -46037,7 +46033,7 @@ impl<'a, C, NC, A> VpnTunnelAggregatedListCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VpnTunnelAggregatedListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VpnTunnelAggregatedListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -46078,10 +46074,10 @@ impl<'a, C, NC, A> VpnTunnelAggregatedListCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct RegionOperationListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RegionOperationListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _region: String, _page_token: Option, @@ -46092,9 +46088,9 @@ pub struct RegionOperationListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RegionOperationListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RegionOperationListCall<'a, C, A> {} -impl<'a, C, NC, A> RegionOperationListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RegionOperationListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -46236,7 +46232,7 @@ impl<'a, C, NC, A> RegionOperationListCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> RegionOperationListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> RegionOperationListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -46246,7 +46242,7 @@ impl<'a, C, NC, A> RegionOperationListCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Name of the region scoping this request. - pub fn region(mut self, new_value: &str) -> RegionOperationListCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> RegionOperationListCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -46254,7 +46250,7 @@ impl<'a, C, NC, A> RegionOperationListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> RegionOperationListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> RegionOperationListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -46262,7 +46258,7 @@ impl<'a, C, NC, A> RegionOperationListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> RegionOperationListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> RegionOperationListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -46270,7 +46266,7 @@ impl<'a, C, NC, A> RegionOperationListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> RegionOperationListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> RegionOperationListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -46281,7 +46277,7 @@ impl<'a, C, NC, A> RegionOperationListCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RegionOperationListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RegionOperationListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -46302,7 +46298,7 @@ impl<'a, C, NC, A> RegionOperationListCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RegionOperationListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RegionOperationListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -46319,7 +46315,7 @@ impl<'a, C, NC, A> RegionOperationListCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RegionOperationListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RegionOperationListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -46357,10 +46353,10 @@ impl<'a, C, NC, A> RegionOperationListCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct RegionOperationDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RegionOperationDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _region: String, _operation: String, @@ -46369,9 +46365,9 @@ pub struct RegionOperationDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RegionOperationDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RegionOperationDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> RegionOperationDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RegionOperationDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -46494,7 +46490,7 @@ impl<'a, C, NC, A> RegionOperationDeleteCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> RegionOperationDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> RegionOperationDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -46504,7 +46500,7 @@ impl<'a, C, NC, A> RegionOperationDeleteCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Name of the region scoping this request. - pub fn region(mut self, new_value: &str) -> RegionOperationDeleteCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> RegionOperationDeleteCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -46514,7 +46510,7 @@ impl<'a, C, NC, A> RegionOperationDeleteCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Name of the operation resource to delete. - pub fn operation(mut self, new_value: &str) -> RegionOperationDeleteCall<'a, C, NC, A> { + pub fn operation(mut self, new_value: &str) -> RegionOperationDeleteCall<'a, C, A> { self._operation = new_value.to_string(); self } @@ -46525,7 +46521,7 @@ impl<'a, C, NC, A> RegionOperationDeleteCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RegionOperationDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RegionOperationDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -46546,7 +46542,7 @@ impl<'a, C, NC, A> RegionOperationDeleteCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RegionOperationDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RegionOperationDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -46563,7 +46559,7 @@ impl<'a, C, NC, A> RegionOperationDeleteCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RegionOperationDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RegionOperationDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -46601,10 +46597,10 @@ impl<'a, C, NC, A> RegionOperationDeleteCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct RegionOperationGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RegionOperationGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Compute, + hub: &'a Compute, _project: String, _region: String, _operation: String, @@ -46613,9 +46609,9 @@ pub struct RegionOperationGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RegionOperationGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RegionOperationGetCall<'a, C, A> {} -impl<'a, C, NC, A> RegionOperationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RegionOperationGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -46749,7 +46745,7 @@ impl<'a, C, NC, A> RegionOperationGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Project ID for this request. - pub fn project(mut self, new_value: &str) -> RegionOperationGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> RegionOperationGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -46759,7 +46755,7 @@ impl<'a, C, NC, A> RegionOperationGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Name of the zone scoping this request. - pub fn region(mut self, new_value: &str) -> RegionOperationGetCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> RegionOperationGetCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -46769,7 +46765,7 @@ impl<'a, C, NC, A> RegionOperationGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Name of the operation resource to return. - pub fn operation(mut self, new_value: &str) -> RegionOperationGetCall<'a, C, NC, A> { + pub fn operation(mut self, new_value: &str) -> RegionOperationGetCall<'a, C, A> { self._operation = new_value.to_string(); self } @@ -46780,7 +46776,7 @@ impl<'a, C, NC, A> RegionOperationGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RegionOperationGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RegionOperationGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -46801,7 +46797,7 @@ impl<'a, C, NC, A> RegionOperationGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RegionOperationGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RegionOperationGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -46818,7 +46814,7 @@ impl<'a, C, NC, A> RegionOperationGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RegionOperationGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RegionOperationGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/container1_beta1/Cargo.toml b/gen/container1_beta1/Cargo.toml index 73f97f574ab..ecbb6b37287 100644 --- a/gen/container1_beta1/Cargo.toml +++ b/gen/container1_beta1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-container1_beta1" -version = "0.1.4+20150318" +version = "0.1.5+20150318" authors = ["Sebastian Thiel "] description = "A complete library to interact with container (protocol v1beta1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/container1_beta1" homepage = "https://cloud.google.com/container-engine/docs/v1beta1/" -documentation = "http://byron.github.io/google-apis-rs/google-container1_beta1" +documentation = "http://byron.github.io/google-apis-rs/google_container1_beta1" license = "MIT" keywords = ["container", "google", "protocol", "web", "api"] diff --git a/gen/container1_beta1/README.md b/gen/container1_beta1/README.md index 2e1bbbf9d6b..9b205b8d4fe 100644 --- a/gen/container1_beta1/README.md +++ b/gen/container1_beta1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-container1_beta1` library allows access to all features of the *Google container* service. -This documentation was generated from *container* crate version *0.1.4+20150318*, where *20150318* is the exact revision of the *container:v1beta1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *container* crate version *0.1.5+20150318*, where *20150318* is the exact revision of the *container:v1beta1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *container* *v1_beta1* API can be found at the [official documentation site](https://cloud.google.com/container-engine/docs/v1beta1/). diff --git a/gen/container1_beta1/src/cmn.rs b/gen/container1_beta1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/container1_beta1/src/cmn.rs +++ b/gen/container1_beta1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/container1_beta1/src/lib.rs b/gen/container1_beta1/src/lib.rs index e6eae1c7ec1..49fb57e126c 100644 --- a/gen/container1_beta1/src/lib.rs +++ b/gen/container1_beta1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *container* crate version *0.1.4+20150318*, where *20150318* is the exact revision of the *container:v1beta1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *container* crate version *0.1.5+20150318*, where *20150318* is the exact revision of the *container:v1beta1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *container* *v1_beta1* API can be found at the //! [official documentation site](https://cloud.google.com/container-engine/docs/v1beta1/). @@ -190,7 +190,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -281,34 +280,31 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Container { +pub struct Container { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Container {} +impl<'a, C, A> Hub for Container {} -impl<'a, C, NC, A> Container - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Container + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Container { + pub fn new(client: C, authenticator: A) -> Container { Container { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn projects(&'a self) -> ProjectMethods<'a, C, NC, A> { + pub fn projects(&'a self) -> ProjectMethods<'a, C, A> { ProjectMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -605,15 +601,15 @@ impl RequestValue for CreateClusterRequest {} /// let rb = hub.projects(); /// # } /// ``` -pub struct ProjectMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Container, + hub: &'a Container, } -impl<'a, C, NC, A> MethodsBuilder for ProjectMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ProjectMethods<'a, C, A> {} -impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { +impl<'a, C, A> ProjectMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -624,7 +620,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// * `projectId` - The Google Developers Console project ID or project number. /// * `zoneId` - The name of the Google Compute Engine zone in which the cluster resides. /// * `clusterId` - The name of the cluster to retrieve. - pub fn zones_clusters_get(&self, project_id: &str, zone_id: &str, cluster_id: &str) -> ProjectZoneClusterGetCall<'a, C, NC, A> { + pub fn zones_clusters_get(&self, project_id: &str, zone_id: &str, cluster_id: &str) -> ProjectZoneClusterGetCall<'a, C, A> { ProjectZoneClusterGetCall { hub: self.hub, _project_id: project_id.to_string(), @@ -643,7 +639,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// # Arguments /// /// * `projectId` - The Google Developers Console project ID or project number. - pub fn operations_list(&self, project_id: &str) -> ProjectOperationListCall<'a, C, NC, A> { + pub fn operations_list(&self, project_id: &str) -> ProjectOperationListCall<'a, C, A> { ProjectOperationListCall { hub: self.hub, _project_id: project_id.to_string(), @@ -664,7 +660,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// * `projectId` - The Google Developers Console project ID or project number. /// * `zoneId` - The name of the Google Compute Engine zone in which the cluster resides. /// * `clusterId` - The name of the cluster to delete. - pub fn zones_clusters_delete(&self, project_id: &str, zone_id: &str, cluster_id: &str) -> ProjectZoneClusterDeleteCall<'a, C, NC, A> { + pub fn zones_clusters_delete(&self, project_id: &str, zone_id: &str, cluster_id: &str) -> ProjectZoneClusterDeleteCall<'a, C, A> { ProjectZoneClusterDeleteCall { hub: self.hub, _project_id: project_id.to_string(), @@ -683,7 +679,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// # Arguments /// /// * `projectId` - The Google Developers Console project ID or project number. - pub fn clusters_list(&self, project_id: &str) -> ProjectClusterListCall<'a, C, NC, A> { + pub fn clusters_list(&self, project_id: &str) -> ProjectClusterListCall<'a, C, A> { ProjectClusterListCall { hub: self.hub, _project_id: project_id.to_string(), @@ -702,7 +698,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// * `projectId` - The Google Developers Console project ID or project number. /// * `zoneId` - The name of the Google Compute Engine zone in which the operation resides. This is always the same zone as the cluster with which the operation is associated. /// * `operationId` - The server-assigned name of the operation. - pub fn zones_operations_get(&self, project_id: &str, zone_id: &str, operation_id: &str) -> ProjectZoneOperationGetCall<'a, C, NC, A> { + pub fn zones_operations_get(&self, project_id: &str, zone_id: &str, operation_id: &str) -> ProjectZoneOperationGetCall<'a, C, A> { ProjectZoneOperationGetCall { hub: self.hub, _project_id: project_id.to_string(), @@ -722,7 +718,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// /// * `projectId` - The Google Developers Console project ID or project number. /// * `zoneId` - The name of the Google Compute Engine zone to return operations for. - pub fn zones_operations_list(&self, project_id: &str, zone_id: &str) -> ProjectZoneOperationListCall<'a, C, NC, A> { + pub fn zones_operations_list(&self, project_id: &str, zone_id: &str) -> ProjectZoneOperationListCall<'a, C, A> { ProjectZoneOperationListCall { hub: self.hub, _project_id: project_id.to_string(), @@ -741,7 +737,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// /// * `projectId` - The Google Developers Console project ID or project number. /// * `zoneId` - The name of the Google Compute Engine zone in which the cluster resides. - pub fn zones_clusters_list(&self, project_id: &str, zone_id: &str) -> ProjectZoneClusterListCall<'a, C, NC, A> { + pub fn zones_clusters_list(&self, project_id: &str, zone_id: &str) -> ProjectZoneClusterListCall<'a, C, A> { ProjectZoneClusterListCall { hub: self.hub, _project_id: project_id.to_string(), @@ -767,7 +763,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `projectId` - The Google Developers Console project ID or project number. /// * `zoneId` - The name of the Google Compute Engine zone in which the cluster resides. - pub fn zones_clusters_create(&self, request: &CreateClusterRequest, project_id: &str, zone_id: &str) -> ProjectZoneClusterCreateCall<'a, C, NC, A> { + pub fn zones_clusters_create(&self, request: &CreateClusterRequest, project_id: &str, zone_id: &str) -> ProjectZoneClusterCreateCall<'a, C, A> { ProjectZoneClusterCreateCall { hub: self.hub, _request: request.clone(), @@ -818,10 +814,10 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct ProjectZoneClusterGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectZoneClusterGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Container, + hub: &'a Container, _project_id: String, _zone_id: String, _cluster_id: String, @@ -830,9 +826,9 @@ pub struct ProjectZoneClusterGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectZoneClusterGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectZoneClusterGetCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectZoneClusterGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectZoneClusterGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -966,7 +962,7 @@ impl<'a, C, NC, A> ProjectZoneClusterGetCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The Google Developers Console project ID or project number. - pub fn project_id(mut self, new_value: &str) -> ProjectZoneClusterGetCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> ProjectZoneClusterGetCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -976,7 +972,7 @@ impl<'a, C, NC, A> ProjectZoneClusterGetCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The name of the Google Compute Engine zone in which the cluster resides. - pub fn zone_id(mut self, new_value: &str) -> ProjectZoneClusterGetCall<'a, C, NC, A> { + pub fn zone_id(mut self, new_value: &str) -> ProjectZoneClusterGetCall<'a, C, A> { self._zone_id = new_value.to_string(); self } @@ -986,7 +982,7 @@ impl<'a, C, NC, A> ProjectZoneClusterGetCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The name of the cluster to retrieve. - pub fn cluster_id(mut self, new_value: &str) -> ProjectZoneClusterGetCall<'a, C, NC, A> { + pub fn cluster_id(mut self, new_value: &str) -> ProjectZoneClusterGetCall<'a, C, A> { self._cluster_id = new_value.to_string(); self } @@ -997,7 +993,7 @@ impl<'a, C, NC, A> ProjectZoneClusterGetCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectZoneClusterGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectZoneClusterGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1018,7 +1014,7 @@ impl<'a, C, NC, A> ProjectZoneClusterGetCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectZoneClusterGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectZoneClusterGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1035,7 +1031,7 @@ impl<'a, C, NC, A> ProjectZoneClusterGetCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectZoneClusterGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectZoneClusterGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1073,19 +1069,19 @@ impl<'a, C, NC, A> ProjectZoneClusterGetCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct ProjectOperationListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectOperationListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Container, + hub: &'a Container, _project_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectOperationListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectOperationListCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectOperationListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectOperationListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1217,7 +1213,7 @@ impl<'a, C, NC, A> ProjectOperationListCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The Google Developers Console project ID or project number. - pub fn project_id(mut self, new_value: &str) -> ProjectOperationListCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> ProjectOperationListCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -1228,7 +1224,7 @@ impl<'a, C, NC, A> ProjectOperationListCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectOperationListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectOperationListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1249,7 +1245,7 @@ impl<'a, C, NC, A> ProjectOperationListCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectOperationListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectOperationListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1266,7 +1262,7 @@ impl<'a, C, NC, A> ProjectOperationListCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectOperationListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectOperationListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1306,10 +1302,10 @@ impl<'a, C, NC, A> ProjectOperationListCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct ProjectZoneClusterDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectZoneClusterDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Container, + hub: &'a Container, _project_id: String, _zone_id: String, _cluster_id: String, @@ -1318,9 +1314,9 @@ pub struct ProjectZoneClusterDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectZoneClusterDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectZoneClusterDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectZoneClusterDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectZoneClusterDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1454,7 +1450,7 @@ impl<'a, C, NC, A> ProjectZoneClusterDeleteCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The Google Developers Console project ID or project number. - pub fn project_id(mut self, new_value: &str) -> ProjectZoneClusterDeleteCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> ProjectZoneClusterDeleteCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -1464,7 +1460,7 @@ impl<'a, C, NC, A> ProjectZoneClusterDeleteCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The name of the Google Compute Engine zone in which the cluster resides. - pub fn zone_id(mut self, new_value: &str) -> ProjectZoneClusterDeleteCall<'a, C, NC, A> { + pub fn zone_id(mut self, new_value: &str) -> ProjectZoneClusterDeleteCall<'a, C, A> { self._zone_id = new_value.to_string(); self } @@ -1474,7 +1470,7 @@ impl<'a, C, NC, A> ProjectZoneClusterDeleteCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The name of the cluster to delete. - pub fn cluster_id(mut self, new_value: &str) -> ProjectZoneClusterDeleteCall<'a, C, NC, A> { + pub fn cluster_id(mut self, new_value: &str) -> ProjectZoneClusterDeleteCall<'a, C, A> { self._cluster_id = new_value.to_string(); self } @@ -1485,7 +1481,7 @@ impl<'a, C, NC, A> ProjectZoneClusterDeleteCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectZoneClusterDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectZoneClusterDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1506,7 +1502,7 @@ impl<'a, C, NC, A> ProjectZoneClusterDeleteCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectZoneClusterDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectZoneClusterDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1523,7 +1519,7 @@ impl<'a, C, NC, A> ProjectZoneClusterDeleteCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectZoneClusterDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectZoneClusterDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1561,19 +1557,19 @@ impl<'a, C, NC, A> ProjectZoneClusterDeleteCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct ProjectClusterListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectClusterListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Container, + hub: &'a Container, _project_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectClusterListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectClusterListCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectClusterListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectClusterListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1705,7 +1701,7 @@ impl<'a, C, NC, A> ProjectClusterListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The Google Developers Console project ID or project number. - pub fn project_id(mut self, new_value: &str) -> ProjectClusterListCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> ProjectClusterListCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -1716,7 +1712,7 @@ impl<'a, C, NC, A> ProjectClusterListCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectClusterListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectClusterListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1737,7 +1733,7 @@ impl<'a, C, NC, A> ProjectClusterListCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectClusterListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectClusterListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1754,7 +1750,7 @@ impl<'a, C, NC, A> ProjectClusterListCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectClusterListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectClusterListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1792,10 +1788,10 @@ impl<'a, C, NC, A> ProjectClusterListCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct ProjectZoneOperationGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectZoneOperationGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Container, + hub: &'a Container, _project_id: String, _zone_id: String, _operation_id: String, @@ -1804,9 +1800,9 @@ pub struct ProjectZoneOperationGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectZoneOperationGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectZoneOperationGetCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectZoneOperationGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1940,7 +1936,7 @@ impl<'a, C, NC, A> ProjectZoneOperationGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The Google Developers Console project ID or project number. - pub fn project_id(mut self, new_value: &str) -> ProjectZoneOperationGetCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> ProjectZoneOperationGetCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -1950,7 +1946,7 @@ impl<'a, C, NC, A> ProjectZoneOperationGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The name of the Google Compute Engine zone in which the operation resides. This is always the same zone as the cluster with which the operation is associated. - pub fn zone_id(mut self, new_value: &str) -> ProjectZoneOperationGetCall<'a, C, NC, A> { + pub fn zone_id(mut self, new_value: &str) -> ProjectZoneOperationGetCall<'a, C, A> { self._zone_id = new_value.to_string(); self } @@ -1960,7 +1956,7 @@ impl<'a, C, NC, A> ProjectZoneOperationGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The server-assigned name of the operation. - pub fn operation_id(mut self, new_value: &str) -> ProjectZoneOperationGetCall<'a, C, NC, A> { + pub fn operation_id(mut self, new_value: &str) -> ProjectZoneOperationGetCall<'a, C, A> { self._operation_id = new_value.to_string(); self } @@ -1971,7 +1967,7 @@ impl<'a, C, NC, A> ProjectZoneOperationGetCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectZoneOperationGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectZoneOperationGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1992,7 +1988,7 @@ impl<'a, C, NC, A> ProjectZoneOperationGetCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectZoneOperationGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectZoneOperationGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2009,7 +2005,7 @@ impl<'a, C, NC, A> ProjectZoneOperationGetCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectZoneOperationGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectZoneOperationGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2047,10 +2043,10 @@ impl<'a, C, NC, A> ProjectZoneOperationGetCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct ProjectZoneOperationListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectZoneOperationListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Container, + hub: &'a Container, _project_id: String, _zone_id: String, _delegate: Option<&'a mut Delegate>, @@ -2058,9 +2054,9 @@ pub struct ProjectZoneOperationListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectZoneOperationListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectZoneOperationListCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectZoneOperationListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2193,7 +2189,7 @@ impl<'a, C, NC, A> ProjectZoneOperationListCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The Google Developers Console project ID or project number. - pub fn project_id(mut self, new_value: &str) -> ProjectZoneOperationListCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> ProjectZoneOperationListCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -2203,7 +2199,7 @@ impl<'a, C, NC, A> ProjectZoneOperationListCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The name of the Google Compute Engine zone to return operations for. - pub fn zone_id(mut self, new_value: &str) -> ProjectZoneOperationListCall<'a, C, NC, A> { + pub fn zone_id(mut self, new_value: &str) -> ProjectZoneOperationListCall<'a, C, A> { self._zone_id = new_value.to_string(); self } @@ -2214,7 +2210,7 @@ impl<'a, C, NC, A> ProjectZoneOperationListCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectZoneOperationListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectZoneOperationListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2235,7 +2231,7 @@ impl<'a, C, NC, A> ProjectZoneOperationListCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectZoneOperationListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectZoneOperationListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2252,7 +2248,7 @@ impl<'a, C, NC, A> ProjectZoneOperationListCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectZoneOperationListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectZoneOperationListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2290,10 +2286,10 @@ impl<'a, C, NC, A> ProjectZoneOperationListCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct ProjectZoneClusterListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectZoneClusterListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Container, + hub: &'a Container, _project_id: String, _zone_id: String, _delegate: Option<&'a mut Delegate>, @@ -2301,9 +2297,9 @@ pub struct ProjectZoneClusterListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectZoneClusterListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectZoneClusterListCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectZoneClusterListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectZoneClusterListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2436,7 +2432,7 @@ impl<'a, C, NC, A> ProjectZoneClusterListCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The Google Developers Console project ID or project number. - pub fn project_id(mut self, new_value: &str) -> ProjectZoneClusterListCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> ProjectZoneClusterListCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -2446,7 +2442,7 @@ impl<'a, C, NC, A> ProjectZoneClusterListCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The name of the Google Compute Engine zone in which the cluster resides. - pub fn zone_id(mut self, new_value: &str) -> ProjectZoneClusterListCall<'a, C, NC, A> { + pub fn zone_id(mut self, new_value: &str) -> ProjectZoneClusterListCall<'a, C, A> { self._zone_id = new_value.to_string(); self } @@ -2457,7 +2453,7 @@ impl<'a, C, NC, A> ProjectZoneClusterListCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectZoneClusterListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectZoneClusterListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2478,7 +2474,7 @@ impl<'a, C, NC, A> ProjectZoneClusterListCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectZoneClusterListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectZoneClusterListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2495,7 +2491,7 @@ impl<'a, C, NC, A> ProjectZoneClusterListCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectZoneClusterListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectZoneClusterListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2545,10 +2541,10 @@ impl<'a, C, NC, A> ProjectZoneClusterListCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct ProjectZoneClusterCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectZoneClusterCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Container, + hub: &'a Container, _request: CreateClusterRequest, _project_id: String, _zone_id: String, @@ -2557,9 +2553,9 @@ pub struct ProjectZoneClusterCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectZoneClusterCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectZoneClusterCreateCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectZoneClusterCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectZoneClusterCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2699,7 +2695,7 @@ impl<'a, C, NC, A> ProjectZoneClusterCreateCall<'a, C, NC, A> where NC: hyper::n /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CreateClusterRequest) -> ProjectZoneClusterCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CreateClusterRequest) -> ProjectZoneClusterCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2709,7 +2705,7 @@ impl<'a, C, NC, A> ProjectZoneClusterCreateCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The Google Developers Console project ID or project number. - pub fn project_id(mut self, new_value: &str) -> ProjectZoneClusterCreateCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> ProjectZoneClusterCreateCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -2719,7 +2715,7 @@ impl<'a, C, NC, A> ProjectZoneClusterCreateCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The name of the Google Compute Engine zone in which the cluster resides. - pub fn zone_id(mut self, new_value: &str) -> ProjectZoneClusterCreateCall<'a, C, NC, A> { + pub fn zone_id(mut self, new_value: &str) -> ProjectZoneClusterCreateCall<'a, C, A> { self._zone_id = new_value.to_string(); self } @@ -2730,7 +2726,7 @@ impl<'a, C, NC, A> ProjectZoneClusterCreateCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectZoneClusterCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectZoneClusterCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2751,7 +2747,7 @@ impl<'a, C, NC, A> ProjectZoneClusterCreateCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectZoneClusterCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectZoneClusterCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2768,7 +2764,7 @@ impl<'a, C, NC, A> ProjectZoneClusterCreateCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectZoneClusterCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectZoneClusterCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/content2/Cargo.toml b/gen/content2/Cargo.toml index 5a033f82b3e..c993dd935a3 100644 --- a/gen/content2/Cargo.toml +++ b/gen/content2/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-content2" -version = "0.1.4+20150317" +version = "0.1.5+20150317" authors = ["Sebastian Thiel "] description = "A complete library to interact with Shopping Content (protocol v2)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/content2" homepage = "https://developers.google.com/shopping-content/v2/" -documentation = "http://byron.github.io/google-apis-rs/google-content2" +documentation = "http://byron.github.io/google-apis-rs/google_content2" license = "MIT" keywords = ["content", "google", "protocol", "web", "api"] diff --git a/gen/content2/README.md b/gen/content2/README.md index 29d2a111c5d..75ab8a33b17 100644 --- a/gen/content2/README.md +++ b/gen/content2/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-content2` library allows access to all features of the *Google Shopping Content* service. -This documentation was generated from *Shopping Content* crate version *0.1.4+20150317*, where *20150317* is the exact revision of the *content:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *Shopping Content* crate version *0.1.5+20150317*, where *20150317* is the exact revision of the *content:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *Shopping Content* *v2* API can be found at the [official documentation site](https://developers.google.com/shopping-content/v2/). diff --git a/gen/content2/src/cmn.rs b/gen/content2/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/content2/src/cmn.rs +++ b/gen/content2/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/content2/src/lib.rs b/gen/content2/src/lib.rs index 54f478b580e..905af899db9 100644 --- a/gen/content2/src/lib.rs +++ b/gen/content2/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *Shopping Content* crate version *0.1.4+20150317*, where *20150317* is the exact revision of the *content:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *Shopping Content* crate version *0.1.5+20150317*, where *20150317* is the exact revision of the *content:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *Shopping Content* *v2* API can be found at the //! [official documentation site](https://developers.google.com/shopping-content/v2/). @@ -217,7 +217,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -314,58 +313,55 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct ShoppingContent { +pub struct ShoppingContent { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for ShoppingContent {} +impl<'a, C, A> Hub for ShoppingContent {} -impl<'a, C, NC, A> ShoppingContent - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ShoppingContent + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> ShoppingContent { + pub fn new(client: C, authenticator: A) -> ShoppingContent { ShoppingContent { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn accounts(&'a self) -> AccountMethods<'a, C, NC, A> { + pub fn accounts(&'a self) -> AccountMethods<'a, C, A> { AccountMethods { hub: &self } } - pub fn accountshipping(&'a self) -> AccountshippingMethods<'a, C, NC, A> { + pub fn accountshipping(&'a self) -> AccountshippingMethods<'a, C, A> { AccountshippingMethods { hub: &self } } - pub fn accountstatuses(&'a self) -> AccountstatuseMethods<'a, C, NC, A> { + pub fn accountstatuses(&'a self) -> AccountstatuseMethods<'a, C, A> { AccountstatuseMethods { hub: &self } } - pub fn accounttax(&'a self) -> AccounttaxMethods<'a, C, NC, A> { + pub fn accounttax(&'a self) -> AccounttaxMethods<'a, C, A> { AccounttaxMethods { hub: &self } } - pub fn datafeeds(&'a self) -> DatafeedMethods<'a, C, NC, A> { + pub fn datafeeds(&'a self) -> DatafeedMethods<'a, C, A> { DatafeedMethods { hub: &self } } - pub fn datafeedstatuses(&'a self) -> DatafeedstatuseMethods<'a, C, NC, A> { + pub fn datafeedstatuses(&'a self) -> DatafeedstatuseMethods<'a, C, A> { DatafeedstatuseMethods { hub: &self } } - pub fn inventory(&'a self) -> InventoryMethods<'a, C, NC, A> { + pub fn inventory(&'a self) -> InventoryMethods<'a, C, A> { InventoryMethods { hub: &self } } - pub fn products(&'a self) -> ProductMethods<'a, C, NC, A> { + pub fn products(&'a self) -> ProductMethods<'a, C, A> { ProductMethods { hub: &self } } - pub fn productstatuses(&'a self) -> ProductstatuseMethods<'a, C, NC, A> { + pub fn productstatuses(&'a self) -> ProductstatuseMethods<'a, C, A> { ProductstatuseMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -2645,15 +2641,15 @@ impl Part for AccountShippingPostalCodeRange {} /// let rb = hub.accounttax(); /// # } /// ``` -pub struct AccounttaxMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccounttaxMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, } -impl<'a, C, NC, A> MethodsBuilder for AccounttaxMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AccounttaxMethods<'a, C, A> {} -impl<'a, C, NC, A> AccounttaxMethods<'a, C, NC, A> { +impl<'a, C, A> AccounttaxMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2662,7 +2658,7 @@ impl<'a, C, NC, A> AccounttaxMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn custombatch(&self, request: &AccounttaxCustomBatchRequest) -> AccounttaxCustombatchCall<'a, C, NC, A> { + pub fn custombatch(&self, request: &AccounttaxCustomBatchRequest) -> AccounttaxCustombatchCall<'a, C, A> { AccounttaxCustombatchCall { hub: self.hub, _request: request.clone(), @@ -2681,7 +2677,7 @@ impl<'a, C, NC, A> AccounttaxMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `merchantId` - The ID of the managing account. /// * `accountId` - The ID of the account for which to get/update account tax settings. - pub fn patch(&self, request: &AccountTax, merchant_id: &str, account_id: &str) -> AccounttaxPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &AccountTax, merchant_id: &str, account_id: &str) -> AccounttaxPatchCall<'a, C, A> { AccounttaxPatchCall { hub: self.hub, _request: request.clone(), @@ -2700,7 +2696,7 @@ impl<'a, C, NC, A> AccounttaxMethods<'a, C, NC, A> { /// # Arguments /// /// * `merchantId` - The ID of the managing account. - pub fn list(&self, merchant_id: &str) -> AccounttaxListCall<'a, C, NC, A> { + pub fn list(&self, merchant_id: &str) -> AccounttaxListCall<'a, C, A> { AccounttaxListCall { hub: self.hub, _merchant_id: merchant_id.to_string(), @@ -2721,7 +2717,7 @@ impl<'a, C, NC, A> AccounttaxMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `merchantId` - The ID of the managing account. /// * `accountId` - The ID of the account for which to get/update account tax settings. - pub fn update(&self, request: &AccountTax, merchant_id: &str, account_id: &str) -> AccounttaxUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &AccountTax, merchant_id: &str, account_id: &str) -> AccounttaxUpdateCall<'a, C, A> { AccounttaxUpdateCall { hub: self.hub, _request: request.clone(), @@ -2741,7 +2737,7 @@ impl<'a, C, NC, A> AccounttaxMethods<'a, C, NC, A> { /// /// * `merchantId` - The ID of the managing account. /// * `accountId` - The ID of the account for which to get/update account tax settings. - pub fn get(&self, merchant_id: &str, account_id: &str) -> AccounttaxGetCall<'a, C, NC, A> { + pub fn get(&self, merchant_id: &str, account_id: &str) -> AccounttaxGetCall<'a, C, A> { AccounttaxGetCall { hub: self.hub, _merchant_id: merchant_id.to_string(), @@ -2783,15 +2779,15 @@ impl<'a, C, NC, A> AccounttaxMethods<'a, C, NC, A> { /// let rb = hub.datafeedstatuses(); /// # } /// ``` -pub struct DatafeedstatuseMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatafeedstatuseMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, } -impl<'a, C, NC, A> MethodsBuilder for DatafeedstatuseMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for DatafeedstatuseMethods<'a, C, A> {} -impl<'a, C, NC, A> DatafeedstatuseMethods<'a, C, NC, A> { +impl<'a, C, A> DatafeedstatuseMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2801,7 +2797,7 @@ impl<'a, C, NC, A> DatafeedstatuseMethods<'a, C, NC, A> { /// /// * `merchantId` - No description provided. /// * `datafeedId` - No description provided. - pub fn get(&self, merchant_id: &str, datafeed_id: &str) -> DatafeedstatuseGetCall<'a, C, NC, A> { + pub fn get(&self, merchant_id: &str, datafeed_id: &str) -> DatafeedstatuseGetCall<'a, C, A> { DatafeedstatuseGetCall { hub: self.hub, _merchant_id: merchant_id.to_string(), @@ -2819,7 +2815,7 @@ impl<'a, C, NC, A> DatafeedstatuseMethods<'a, C, NC, A> { /// # Arguments /// /// * `merchantId` - The ID of the managing account. - pub fn list(&self, merchant_id: &str) -> DatafeedstatuseListCall<'a, C, NC, A> { + pub fn list(&self, merchant_id: &str) -> DatafeedstatuseListCall<'a, C, A> { DatafeedstatuseListCall { hub: self.hub, _merchant_id: merchant_id.to_string(), @@ -2835,7 +2831,7 @@ impl<'a, C, NC, A> DatafeedstatuseMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn custombatch(&self, request: &DatafeedstatusesCustomBatchRequest) -> DatafeedstatuseCustombatchCall<'a, C, NC, A> { + pub fn custombatch(&self, request: &DatafeedstatusesCustomBatchRequest) -> DatafeedstatuseCustombatchCall<'a, C, A> { DatafeedstatuseCustombatchCall { hub: self.hub, _request: request.clone(), @@ -2876,21 +2872,21 @@ impl<'a, C, NC, A> DatafeedstatuseMethods<'a, C, NC, A> { /// let rb = hub.datafeeds(); /// # } /// ``` -pub struct DatafeedMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatafeedMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, } -impl<'a, C, NC, A> MethodsBuilder for DatafeedMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for DatafeedMethods<'a, C, A> {} -impl<'a, C, NC, A> DatafeedMethods<'a, C, NC, A> { +impl<'a, C, A> DatafeedMethods<'a, C, A> { /// /// # Arguments /// /// * `request` - No description provided. - pub fn custombatch(&self, request: &DatafeedsCustomBatchRequest) -> DatafeedCustombatchCall<'a, C, NC, A> { + pub fn custombatch(&self, request: &DatafeedsCustomBatchRequest) -> DatafeedCustombatchCall<'a, C, A> { DatafeedCustombatchCall { hub: self.hub, _request: request.clone(), @@ -2908,7 +2904,7 @@ impl<'a, C, NC, A> DatafeedMethods<'a, C, NC, A> { /// /// * `merchantId` - No description provided. /// * `datafeedId` - No description provided. - pub fn get(&self, merchant_id: &str, datafeed_id: &str) -> DatafeedGetCall<'a, C, NC, A> { + pub fn get(&self, merchant_id: &str, datafeed_id: &str) -> DatafeedGetCall<'a, C, A> { DatafeedGetCall { hub: self.hub, _merchant_id: merchant_id.to_string(), @@ -2928,7 +2924,7 @@ impl<'a, C, NC, A> DatafeedMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `merchantId` - No description provided. /// * `datafeedId` - No description provided. - pub fn patch(&self, request: &Datafeed, merchant_id: &str, datafeed_id: &str) -> DatafeedPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Datafeed, merchant_id: &str, datafeed_id: &str) -> DatafeedPatchCall<'a, C, A> { DatafeedPatchCall { hub: self.hub, _request: request.clone(), @@ -2948,7 +2944,7 @@ impl<'a, C, NC, A> DatafeedMethods<'a, C, NC, A> { /// /// * `merchantId` - No description provided. /// * `datafeedId` - No description provided. - pub fn delete(&self, merchant_id: &str, datafeed_id: &str) -> DatafeedDeleteCall<'a, C, NC, A> { + pub fn delete(&self, merchant_id: &str, datafeed_id: &str) -> DatafeedDeleteCall<'a, C, A> { DatafeedDeleteCall { hub: self.hub, _merchant_id: merchant_id.to_string(), @@ -2967,7 +2963,7 @@ impl<'a, C, NC, A> DatafeedMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `merchantId` - No description provided. - pub fn insert(&self, request: &Datafeed, merchant_id: &str) -> DatafeedInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Datafeed, merchant_id: &str) -> DatafeedInsertCall<'a, C, A> { DatafeedInsertCall { hub: self.hub, _request: request.clone(), @@ -2985,7 +2981,7 @@ impl<'a, C, NC, A> DatafeedMethods<'a, C, NC, A> { /// # Arguments /// /// * `merchantId` - The ID of the managing account. - pub fn list(&self, merchant_id: &str) -> DatafeedListCall<'a, C, NC, A> { + pub fn list(&self, merchant_id: &str) -> DatafeedListCall<'a, C, A> { DatafeedListCall { hub: self.hub, _merchant_id: merchant_id.to_string(), @@ -3006,7 +3002,7 @@ impl<'a, C, NC, A> DatafeedMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `merchantId` - No description provided. /// * `datafeedId` - No description provided. - pub fn update(&self, request: &Datafeed, merchant_id: &str, datafeed_id: &str) -> DatafeedUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Datafeed, merchant_id: &str, datafeed_id: &str) -> DatafeedUpdateCall<'a, C, A> { DatafeedUpdateCall { hub: self.hub, _request: request.clone(), @@ -3049,15 +3045,15 @@ impl<'a, C, NC, A> DatafeedMethods<'a, C, NC, A> { /// let rb = hub.productstatuses(); /// # } /// ``` -pub struct ProductstatuseMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProductstatuseMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, } -impl<'a, C, NC, A> MethodsBuilder for ProductstatuseMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ProductstatuseMethods<'a, C, A> {} -impl<'a, C, NC, A> ProductstatuseMethods<'a, C, NC, A> { +impl<'a, C, A> ProductstatuseMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3067,7 +3063,7 @@ impl<'a, C, NC, A> ProductstatuseMethods<'a, C, NC, A> { /// /// * `merchantId` - The ID of the managing account. /// * `productId` - The ID of the product. - pub fn get(&self, merchant_id: &str, product_id: &str) -> ProductstatuseGetCall<'a, C, NC, A> { + pub fn get(&self, merchant_id: &str, product_id: &str) -> ProductstatuseGetCall<'a, C, A> { ProductstatuseGetCall { hub: self.hub, _merchant_id: merchant_id.to_string(), @@ -3085,7 +3081,7 @@ impl<'a, C, NC, A> ProductstatuseMethods<'a, C, NC, A> { /// # Arguments /// /// * `merchantId` - The ID of the managing account. - pub fn list(&self, merchant_id: &str) -> ProductstatuseListCall<'a, C, NC, A> { + pub fn list(&self, merchant_id: &str) -> ProductstatuseListCall<'a, C, A> { ProductstatuseListCall { hub: self.hub, _merchant_id: merchant_id.to_string(), @@ -3104,7 +3100,7 @@ impl<'a, C, NC, A> ProductstatuseMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn custombatch(&self, request: &ProductstatusesCustomBatchRequest) -> ProductstatuseCustombatchCall<'a, C, NC, A> { + pub fn custombatch(&self, request: &ProductstatusesCustomBatchRequest) -> ProductstatuseCustombatchCall<'a, C, A> { ProductstatuseCustombatchCall { hub: self.hub, _request: request.clone(), @@ -3145,20 +3141,20 @@ impl<'a, C, NC, A> ProductstatuseMethods<'a, C, NC, A> { /// let rb = hub.accounts(); /// # } /// ``` -pub struct AccountMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, } -impl<'a, C, NC, A> MethodsBuilder for AccountMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AccountMethods<'a, C, A> {} -impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { +impl<'a, C, A> AccountMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Returns information about the authenticated user. - pub fn authinfo(&self) -> AccountAuthinfoCall<'a, C, NC, A> { + pub fn authinfo(&self) -> AccountAuthinfoCall<'a, C, A> { AccountAuthinfoCall { hub: self.hub, _delegate: Default::default(), @@ -3176,7 +3172,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `merchantId` - The ID of the managing account. /// * `accountId` - The ID of the account. - pub fn patch(&self, request: &Account, merchant_id: &str, account_id: &str) -> AccountPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Account, merchant_id: &str, account_id: &str) -> AccountPatchCall<'a, C, A> { AccountPatchCall { hub: self.hub, _request: request.clone(), @@ -3196,7 +3192,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `merchantId` - The ID of the managing account. /// * `accountId` - The ID of the account. - pub fn get(&self, merchant_id: &str, account_id: &str) -> AccountGetCall<'a, C, NC, A> { + pub fn get(&self, merchant_id: &str, account_id: &str) -> AccountGetCall<'a, C, A> { AccountGetCall { hub: self.hub, _merchant_id: merchant_id.to_string(), @@ -3216,7 +3212,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `merchantId` - The ID of the managing account. /// * `accountId` - The ID of the account. - pub fn update(&self, request: &Account, merchant_id: &str, account_id: &str) -> AccountUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Account, merchant_id: &str, account_id: &str) -> AccountUpdateCall<'a, C, A> { AccountUpdateCall { hub: self.hub, _request: request.clone(), @@ -3235,7 +3231,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `merchantId` - The ID of the managing account. - pub fn list(&self, merchant_id: &str) -> AccountListCall<'a, C, NC, A> { + pub fn list(&self, merchant_id: &str) -> AccountListCall<'a, C, A> { AccountListCall { hub: self.hub, _merchant_id: merchant_id.to_string(), @@ -3255,7 +3251,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `merchantId` - The ID of the managing account. /// * `accountId` - The ID of the account. - pub fn delete(&self, merchant_id: &str, account_id: &str) -> AccountDeleteCall<'a, C, NC, A> { + pub fn delete(&self, merchant_id: &str, account_id: &str) -> AccountDeleteCall<'a, C, A> { AccountDeleteCall { hub: self.hub, _merchant_id: merchant_id.to_string(), @@ -3273,7 +3269,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn custombatch(&self, request: &AccountsCustomBatchRequest) -> AccountCustombatchCall<'a, C, NC, A> { + pub fn custombatch(&self, request: &AccountsCustomBatchRequest) -> AccountCustombatchCall<'a, C, A> { AccountCustombatchCall { hub: self.hub, _request: request.clone(), @@ -3291,7 +3287,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `merchantId` - The ID of the managing account. - pub fn insert(&self, request: &Account, merchant_id: &str) -> AccountInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Account, merchant_id: &str) -> AccountInsertCall<'a, C, A> { AccountInsertCall { hub: self.hub, _request: request.clone(), @@ -3333,15 +3329,15 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// let rb = hub.inventory(); /// # } /// ``` -pub struct InventoryMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InventoryMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, } -impl<'a, C, NC, A> MethodsBuilder for InventoryMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for InventoryMethods<'a, C, A> {} -impl<'a, C, NC, A> InventoryMethods<'a, C, NC, A> { +impl<'a, C, A> InventoryMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3353,7 +3349,7 @@ impl<'a, C, NC, A> InventoryMethods<'a, C, NC, A> { /// * `merchantId` - The ID of the managing account. /// * `storeCode` - The code of the store for which to update price and availability. Use online to update price and availability of an online product. /// * `productId` - The ID of the product for which to update price and availability. - pub fn set(&self, request: &InventorySetRequest, merchant_id: &str, store_code: &str, product_id: &str) -> InventorySetCall<'a, C, NC, A> { + pub fn set(&self, request: &InventorySetRequest, merchant_id: &str, store_code: &str, product_id: &str) -> InventorySetCall<'a, C, A> { InventorySetCall { hub: self.hub, _request: request.clone(), @@ -3373,7 +3369,7 @@ impl<'a, C, NC, A> InventoryMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn custombatch(&self, request: &InventoryCustomBatchRequest) -> InventoryCustombatchCall<'a, C, NC, A> { + pub fn custombatch(&self, request: &InventoryCustomBatchRequest) -> InventoryCustombatchCall<'a, C, A> { InventoryCustombatchCall { hub: self.hub, _request: request.clone(), @@ -3414,15 +3410,15 @@ impl<'a, C, NC, A> InventoryMethods<'a, C, NC, A> { /// let rb = hub.accountstatuses(); /// # } /// ``` -pub struct AccountstatuseMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountstatuseMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, } -impl<'a, C, NC, A> MethodsBuilder for AccountstatuseMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AccountstatuseMethods<'a, C, A> {} -impl<'a, C, NC, A> AccountstatuseMethods<'a, C, NC, A> { +impl<'a, C, A> AccountstatuseMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3432,7 +3428,7 @@ impl<'a, C, NC, A> AccountstatuseMethods<'a, C, NC, A> { /// /// * `merchantId` - The ID of the managing account. /// * `accountId` - The ID of the account. - pub fn get(&self, merchant_id: &str, account_id: &str) -> AccountstatuseGetCall<'a, C, NC, A> { + pub fn get(&self, merchant_id: &str, account_id: &str) -> AccountstatuseGetCall<'a, C, A> { AccountstatuseGetCall { hub: self.hub, _merchant_id: merchant_id.to_string(), @@ -3450,7 +3446,7 @@ impl<'a, C, NC, A> AccountstatuseMethods<'a, C, NC, A> { /// # Arguments /// /// * `merchantId` - The ID of the managing account. - pub fn list(&self, merchant_id: &str) -> AccountstatuseListCall<'a, C, NC, A> { + pub fn list(&self, merchant_id: &str) -> AccountstatuseListCall<'a, C, A> { AccountstatuseListCall { hub: self.hub, _merchant_id: merchant_id.to_string(), @@ -3466,7 +3462,7 @@ impl<'a, C, NC, A> AccountstatuseMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn custombatch(&self, request: &AccountstatusesCustomBatchRequest) -> AccountstatuseCustombatchCall<'a, C, NC, A> { + pub fn custombatch(&self, request: &AccountstatusesCustomBatchRequest) -> AccountstatuseCustombatchCall<'a, C, A> { AccountstatuseCustombatchCall { hub: self.hub, _request: request.clone(), @@ -3507,15 +3503,15 @@ impl<'a, C, NC, A> AccountstatuseMethods<'a, C, NC, A> { /// let rb = hub.products(); /// # } /// ``` -pub struct ProductMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProductMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, } -impl<'a, C, NC, A> MethodsBuilder for ProductMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ProductMethods<'a, C, A> {} -impl<'a, C, NC, A> ProductMethods<'a, C, NC, A> { +impl<'a, C, A> ProductMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3524,7 +3520,7 @@ impl<'a, C, NC, A> ProductMethods<'a, C, NC, A> { /// # Arguments /// /// * `merchantId` - The ID of the managing account. - pub fn list(&self, merchant_id: &str) -> ProductListCall<'a, C, NC, A> { + pub fn list(&self, merchant_id: &str) -> ProductListCall<'a, C, A> { ProductListCall { hub: self.hub, _merchant_id: merchant_id.to_string(), @@ -3544,7 +3540,7 @@ impl<'a, C, NC, A> ProductMethods<'a, C, NC, A> { /// /// * `merchantId` - The ID of the managing account. /// * `productId` - The ID of the product. - pub fn get(&self, merchant_id: &str, product_id: &str) -> ProductGetCall<'a, C, NC, A> { + pub fn get(&self, merchant_id: &str, product_id: &str) -> ProductGetCall<'a, C, A> { ProductGetCall { hub: self.hub, _merchant_id: merchant_id.to_string(), @@ -3563,7 +3559,7 @@ impl<'a, C, NC, A> ProductMethods<'a, C, NC, A> { /// /// * `merchantId` - The ID of the managing account. /// * `productId` - The ID of the product. - pub fn delete(&self, merchant_id: &str, product_id: &str) -> ProductDeleteCall<'a, C, NC, A> { + pub fn delete(&self, merchant_id: &str, product_id: &str) -> ProductDeleteCall<'a, C, A> { ProductDeleteCall { hub: self.hub, _merchant_id: merchant_id.to_string(), @@ -3582,7 +3578,7 @@ impl<'a, C, NC, A> ProductMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn custombatch(&self, request: &ProductsCustomBatchRequest) -> ProductCustombatchCall<'a, C, NC, A> { + pub fn custombatch(&self, request: &ProductsCustomBatchRequest) -> ProductCustombatchCall<'a, C, A> { ProductCustombatchCall { hub: self.hub, _request: request.clone(), @@ -3601,7 +3597,7 @@ impl<'a, C, NC, A> ProductMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `merchantId` - The ID of the managing account. - pub fn insert(&self, request: &Product, merchant_id: &str) -> ProductInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Product, merchant_id: &str) -> ProductInsertCall<'a, C, A> { ProductInsertCall { hub: self.hub, _request: request.clone(), @@ -3644,15 +3640,15 @@ impl<'a, C, NC, A> ProductMethods<'a, C, NC, A> { /// let rb = hub.accountshipping(); /// # } /// ``` -pub struct AccountshippingMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountshippingMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, } -impl<'a, C, NC, A> MethodsBuilder for AccountshippingMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AccountshippingMethods<'a, C, A> {} -impl<'a, C, NC, A> AccountshippingMethods<'a, C, NC, A> { +impl<'a, C, A> AccountshippingMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3661,7 +3657,7 @@ impl<'a, C, NC, A> AccountshippingMethods<'a, C, NC, A> { /// # Arguments /// /// * `merchantId` - The ID of the managing account. - pub fn list(&self, merchant_id: &str) -> AccountshippingListCall<'a, C, NC, A> { + pub fn list(&self, merchant_id: &str) -> AccountshippingListCall<'a, C, A> { AccountshippingListCall { hub: self.hub, _merchant_id: merchant_id.to_string(), @@ -3682,7 +3678,7 @@ impl<'a, C, NC, A> AccountshippingMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `merchantId` - The ID of the managing account. /// * `accountId` - The ID of the account for which to get/update account shipping settings. - pub fn patch(&self, request: &AccountShipping, merchant_id: &str, account_id: &str) -> AccountshippingPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &AccountShipping, merchant_id: &str, account_id: &str) -> AccountshippingPatchCall<'a, C, A> { AccountshippingPatchCall { hub: self.hub, _request: request.clone(), @@ -3703,7 +3699,7 @@ impl<'a, C, NC, A> AccountshippingMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `merchantId` - The ID of the managing account. /// * `accountId` - The ID of the account for which to get/update account shipping settings. - pub fn update(&self, request: &AccountShipping, merchant_id: &str, account_id: &str) -> AccountshippingUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &AccountShipping, merchant_id: &str, account_id: &str) -> AccountshippingUpdateCall<'a, C, A> { AccountshippingUpdateCall { hub: self.hub, _request: request.clone(), @@ -3722,7 +3718,7 @@ impl<'a, C, NC, A> AccountshippingMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn custombatch(&self, request: &AccountshippingCustomBatchRequest) -> AccountshippingCustombatchCall<'a, C, NC, A> { + pub fn custombatch(&self, request: &AccountshippingCustomBatchRequest) -> AccountshippingCustombatchCall<'a, C, A> { AccountshippingCustombatchCall { hub: self.hub, _request: request.clone(), @@ -3740,7 +3736,7 @@ impl<'a, C, NC, A> AccountshippingMethods<'a, C, NC, A> { /// /// * `merchantId` - The ID of the managing account. /// * `accountId` - The ID of the account for which to get/update account shipping settings. - pub fn get(&self, merchant_id: &str, account_id: &str) -> AccountshippingGetCall<'a, C, NC, A> { + pub fn get(&self, merchant_id: &str, account_id: &str) -> AccountshippingGetCall<'a, C, A> { AccountshippingGetCall { hub: self.hub, _merchant_id: merchant_id.to_string(), @@ -3796,19 +3792,19 @@ impl<'a, C, NC, A> AccountshippingMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct AccounttaxCustombatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccounttaxCustombatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _request: AccounttaxCustomBatchRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccounttaxCustombatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccounttaxCustombatchCall<'a, C, A> {} -impl<'a, C, NC, A> AccounttaxCustombatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccounttaxCustombatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3922,7 +3918,7 @@ impl<'a, C, NC, A> AccounttaxCustombatchCall<'a, C, NC, A> where NC: hyper::net: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AccounttaxCustomBatchRequest) -> AccounttaxCustombatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AccounttaxCustomBatchRequest) -> AccounttaxCustombatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3933,7 +3929,7 @@ impl<'a, C, NC, A> AccounttaxCustombatchCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccounttaxCustombatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccounttaxCustombatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3954,7 +3950,7 @@ impl<'a, C, NC, A> AccounttaxCustombatchCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccounttaxCustombatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccounttaxCustombatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3971,7 +3967,7 @@ impl<'a, C, NC, A> AccounttaxCustombatchCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccounttaxCustombatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccounttaxCustombatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4015,10 +4011,10 @@ impl<'a, C, NC, A> AccounttaxCustombatchCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct AccounttaxPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccounttaxPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _request: AccountTax, _merchant_id: String, _account_id: String, @@ -4027,9 +4023,9 @@ pub struct AccounttaxPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccounttaxPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccounttaxPatchCall<'a, C, A> {} -impl<'a, C, NC, A> AccounttaxPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccounttaxPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4169,7 +4165,7 @@ impl<'a, C, NC, A> AccounttaxPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AccountTax) -> AccounttaxPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AccountTax) -> AccounttaxPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4179,7 +4175,7 @@ impl<'a, C, NC, A> AccounttaxPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> AccounttaxPatchCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> AccounttaxPatchCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -4189,7 +4185,7 @@ impl<'a, C, NC, A> AccounttaxPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the account for which to get/update account tax settings. - pub fn account_id(mut self, new_value: &str) -> AccounttaxPatchCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccounttaxPatchCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -4200,7 +4196,7 @@ impl<'a, C, NC, A> AccounttaxPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccounttaxPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccounttaxPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4221,7 +4217,7 @@ impl<'a, C, NC, A> AccounttaxPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccounttaxPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccounttaxPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4238,7 +4234,7 @@ impl<'a, C, NC, A> AccounttaxPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccounttaxPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccounttaxPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4278,10 +4274,10 @@ impl<'a, C, NC, A> AccounttaxPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct AccounttaxListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccounttaxListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _merchant_id: String, _page_token: Option, _max_results: Option, @@ -4290,9 +4286,9 @@ pub struct AccounttaxListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccounttaxListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccounttaxListCall<'a, C, A> {} -impl<'a, C, NC, A> AccounttaxListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccounttaxListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4430,7 +4426,7 @@ impl<'a, C, NC, A> AccounttaxListCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> AccounttaxListCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> AccounttaxListCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -4438,7 +4434,7 @@ impl<'a, C, NC, A> AccounttaxListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> AccounttaxListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AccounttaxListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -4446,7 +4442,7 @@ impl<'a, C, NC, A> AccounttaxListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The maximum number of tax settings to return in the response, used for paging. - pub fn max_results(mut self, new_value: u32) -> AccounttaxListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> AccounttaxListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -4457,7 +4453,7 @@ impl<'a, C, NC, A> AccounttaxListCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccounttaxListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccounttaxListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4478,7 +4474,7 @@ impl<'a, C, NC, A> AccounttaxListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccounttaxListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccounttaxListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4495,7 +4491,7 @@ impl<'a, C, NC, A> AccounttaxListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccounttaxListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccounttaxListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4539,10 +4535,10 @@ impl<'a, C, NC, A> AccounttaxListCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct AccounttaxUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccounttaxUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _request: AccountTax, _merchant_id: String, _account_id: String, @@ -4551,9 +4547,9 @@ pub struct AccounttaxUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccounttaxUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccounttaxUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AccounttaxUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccounttaxUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4693,7 +4689,7 @@ impl<'a, C, NC, A> AccounttaxUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AccountTax) -> AccounttaxUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AccountTax) -> AccounttaxUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4703,7 +4699,7 @@ impl<'a, C, NC, A> AccounttaxUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> AccounttaxUpdateCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> AccounttaxUpdateCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -4713,7 +4709,7 @@ impl<'a, C, NC, A> AccounttaxUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID of the account for which to get/update account tax settings. - pub fn account_id(mut self, new_value: &str) -> AccounttaxUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccounttaxUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -4724,7 +4720,7 @@ impl<'a, C, NC, A> AccounttaxUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccounttaxUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccounttaxUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4745,7 +4741,7 @@ impl<'a, C, NC, A> AccounttaxUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccounttaxUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccounttaxUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4762,7 +4758,7 @@ impl<'a, C, NC, A> AccounttaxUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccounttaxUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccounttaxUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4800,10 +4796,10 @@ impl<'a, C, NC, A> AccounttaxUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct AccounttaxGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccounttaxGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _merchant_id: String, _account_id: String, _delegate: Option<&'a mut Delegate>, @@ -4811,9 +4807,9 @@ pub struct AccounttaxGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccounttaxGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccounttaxGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccounttaxGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccounttaxGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4946,7 +4942,7 @@ impl<'a, C, NC, A> AccounttaxGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> AccounttaxGetCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> AccounttaxGetCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -4956,7 +4952,7 @@ impl<'a, C, NC, A> AccounttaxGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the account for which to get/update account tax settings. - pub fn account_id(mut self, new_value: &str) -> AccounttaxGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccounttaxGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -4967,7 +4963,7 @@ impl<'a, C, NC, A> AccounttaxGetCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccounttaxGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccounttaxGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4988,7 +4984,7 @@ impl<'a, C, NC, A> AccounttaxGetCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccounttaxGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccounttaxGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5005,7 +5001,7 @@ impl<'a, C, NC, A> AccounttaxGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccounttaxGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccounttaxGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5043,10 +5039,10 @@ impl<'a, C, NC, A> AccounttaxGetCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct DatafeedstatuseGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatafeedstatuseGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _merchant_id: String, _datafeed_id: String, _delegate: Option<&'a mut Delegate>, @@ -5054,9 +5050,9 @@ pub struct DatafeedstatuseGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatafeedstatuseGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatafeedstatuseGetCall<'a, C, A> {} -impl<'a, C, NC, A> DatafeedstatuseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatafeedstatuseGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5188,7 +5184,7 @@ impl<'a, C, NC, A> DatafeedstatuseGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn merchant_id(mut self, new_value: &str) -> DatafeedstatuseGetCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> DatafeedstatuseGetCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -5197,7 +5193,7 @@ impl<'a, C, NC, A> DatafeedstatuseGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn datafeed_id(mut self, new_value: &str) -> DatafeedstatuseGetCall<'a, C, NC, A> { + pub fn datafeed_id(mut self, new_value: &str) -> DatafeedstatuseGetCall<'a, C, A> { self._datafeed_id = new_value.to_string(); self } @@ -5208,7 +5204,7 @@ impl<'a, C, NC, A> DatafeedstatuseGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatafeedstatuseGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatafeedstatuseGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5229,7 +5225,7 @@ impl<'a, C, NC, A> DatafeedstatuseGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatafeedstatuseGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatafeedstatuseGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5246,7 +5242,7 @@ impl<'a, C, NC, A> DatafeedstatuseGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatafeedstatuseGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatafeedstatuseGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5286,10 +5282,10 @@ impl<'a, C, NC, A> DatafeedstatuseGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct DatafeedstatuseListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatafeedstatuseListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _merchant_id: String, _page_token: Option, _max_results: Option, @@ -5298,9 +5294,9 @@ pub struct DatafeedstatuseListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatafeedstatuseListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatafeedstatuseListCall<'a, C, A> {} -impl<'a, C, NC, A> DatafeedstatuseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatafeedstatuseListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5438,7 +5434,7 @@ impl<'a, C, NC, A> DatafeedstatuseListCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> DatafeedstatuseListCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> DatafeedstatuseListCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -5446,7 +5442,7 @@ impl<'a, C, NC, A> DatafeedstatuseListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> DatafeedstatuseListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> DatafeedstatuseListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -5454,7 +5450,7 @@ impl<'a, C, NC, A> DatafeedstatuseListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The maximum number of products to return in the response, used for paging. - pub fn max_results(mut self, new_value: u32) -> DatafeedstatuseListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> DatafeedstatuseListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -5465,7 +5461,7 @@ impl<'a, C, NC, A> DatafeedstatuseListCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatafeedstatuseListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatafeedstatuseListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5486,7 +5482,7 @@ impl<'a, C, NC, A> DatafeedstatuseListCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatafeedstatuseListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatafeedstatuseListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5503,7 +5499,7 @@ impl<'a, C, NC, A> DatafeedstatuseListCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatafeedstatuseListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatafeedstatuseListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5545,19 +5541,19 @@ impl<'a, C, NC, A> DatafeedstatuseListCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct DatafeedstatuseCustombatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatafeedstatuseCustombatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _request: DatafeedstatusesCustomBatchRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatafeedstatuseCustombatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatafeedstatuseCustombatchCall<'a, C, A> {} -impl<'a, C, NC, A> DatafeedstatuseCustombatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatafeedstatuseCustombatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5671,7 +5667,7 @@ impl<'a, C, NC, A> DatafeedstatuseCustombatchCall<'a, C, NC, A> where NC: hyper: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &DatafeedstatusesCustomBatchRequest) -> DatafeedstatuseCustombatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &DatafeedstatusesCustomBatchRequest) -> DatafeedstatuseCustombatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5682,7 +5678,7 @@ impl<'a, C, NC, A> DatafeedstatuseCustombatchCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatafeedstatuseCustombatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatafeedstatuseCustombatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5703,7 +5699,7 @@ impl<'a, C, NC, A> DatafeedstatuseCustombatchCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatafeedstatuseCustombatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatafeedstatuseCustombatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5720,7 +5716,7 @@ impl<'a, C, NC, A> DatafeedstatuseCustombatchCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatafeedstatuseCustombatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatafeedstatuseCustombatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5762,19 +5758,19 @@ impl<'a, C, NC, A> DatafeedstatuseCustombatchCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct DatafeedCustombatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatafeedCustombatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _request: DatafeedsCustomBatchRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatafeedCustombatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatafeedCustombatchCall<'a, C, A> {} -impl<'a, C, NC, A> DatafeedCustombatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatafeedCustombatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5888,7 +5884,7 @@ impl<'a, C, NC, A> DatafeedCustombatchCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &DatafeedsCustomBatchRequest) -> DatafeedCustombatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &DatafeedsCustomBatchRequest) -> DatafeedCustombatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5899,7 +5895,7 @@ impl<'a, C, NC, A> DatafeedCustombatchCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatafeedCustombatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatafeedCustombatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5920,7 +5916,7 @@ impl<'a, C, NC, A> DatafeedCustombatchCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatafeedCustombatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatafeedCustombatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5937,7 +5933,7 @@ impl<'a, C, NC, A> DatafeedCustombatchCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatafeedCustombatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatafeedCustombatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5975,10 +5971,10 @@ impl<'a, C, NC, A> DatafeedCustombatchCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct DatafeedGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatafeedGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _merchant_id: String, _datafeed_id: String, _delegate: Option<&'a mut Delegate>, @@ -5986,9 +5982,9 @@ pub struct DatafeedGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatafeedGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatafeedGetCall<'a, C, A> {} -impl<'a, C, NC, A> DatafeedGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatafeedGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6120,7 +6116,7 @@ impl<'a, C, NC, A> DatafeedGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn merchant_id(mut self, new_value: &str) -> DatafeedGetCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> DatafeedGetCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -6129,7 +6125,7 @@ impl<'a, C, NC, A> DatafeedGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn datafeed_id(mut self, new_value: &str) -> DatafeedGetCall<'a, C, NC, A> { + pub fn datafeed_id(mut self, new_value: &str) -> DatafeedGetCall<'a, C, A> { self._datafeed_id = new_value.to_string(); self } @@ -6140,7 +6136,7 @@ impl<'a, C, NC, A> DatafeedGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatafeedGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatafeedGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6161,7 +6157,7 @@ impl<'a, C, NC, A> DatafeedGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatafeedGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatafeedGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6178,7 +6174,7 @@ impl<'a, C, NC, A> DatafeedGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatafeedGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatafeedGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6222,10 +6218,10 @@ impl<'a, C, NC, A> DatafeedGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct DatafeedPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatafeedPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _request: Datafeed, _merchant_id: String, _datafeed_id: String, @@ -6234,9 +6230,9 @@ pub struct DatafeedPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatafeedPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatafeedPatchCall<'a, C, A> {} -impl<'a, C, NC, A> DatafeedPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatafeedPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6376,7 +6372,7 @@ impl<'a, C, NC, A> DatafeedPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Datafeed) -> DatafeedPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Datafeed) -> DatafeedPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6385,7 +6381,7 @@ impl<'a, C, NC, A> DatafeedPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn merchant_id(mut self, new_value: &str) -> DatafeedPatchCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> DatafeedPatchCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -6394,7 +6390,7 @@ impl<'a, C, NC, A> DatafeedPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn datafeed_id(mut self, new_value: &str) -> DatafeedPatchCall<'a, C, NC, A> { + pub fn datafeed_id(mut self, new_value: &str) -> DatafeedPatchCall<'a, C, A> { self._datafeed_id = new_value.to_string(); self } @@ -6405,7 +6401,7 @@ impl<'a, C, NC, A> DatafeedPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatafeedPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatafeedPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6426,7 +6422,7 @@ impl<'a, C, NC, A> DatafeedPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatafeedPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatafeedPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6443,7 +6439,7 @@ impl<'a, C, NC, A> DatafeedPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatafeedPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatafeedPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6481,10 +6477,10 @@ impl<'a, C, NC, A> DatafeedPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct DatafeedDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatafeedDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _merchant_id: String, _datafeed_id: String, _delegate: Option<&'a mut Delegate>, @@ -6492,9 +6488,9 @@ pub struct DatafeedDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatafeedDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatafeedDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> DatafeedDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatafeedDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6615,7 +6611,7 @@ impl<'a, C, NC, A> DatafeedDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn merchant_id(mut self, new_value: &str) -> DatafeedDeleteCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> DatafeedDeleteCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -6624,7 +6620,7 @@ impl<'a, C, NC, A> DatafeedDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn datafeed_id(mut self, new_value: &str) -> DatafeedDeleteCall<'a, C, NC, A> { + pub fn datafeed_id(mut self, new_value: &str) -> DatafeedDeleteCall<'a, C, A> { self._datafeed_id = new_value.to_string(); self } @@ -6635,7 +6631,7 @@ impl<'a, C, NC, A> DatafeedDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatafeedDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatafeedDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6656,7 +6652,7 @@ impl<'a, C, NC, A> DatafeedDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatafeedDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatafeedDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6673,7 +6669,7 @@ impl<'a, C, NC, A> DatafeedDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatafeedDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatafeedDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6717,10 +6713,10 @@ impl<'a, C, NC, A> DatafeedDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct DatafeedInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatafeedInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _request: Datafeed, _merchant_id: String, _delegate: Option<&'a mut Delegate>, @@ -6728,9 +6724,9 @@ pub struct DatafeedInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatafeedInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatafeedInsertCall<'a, C, A> {} -impl<'a, C, NC, A> DatafeedInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatafeedInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6869,7 +6865,7 @@ impl<'a, C, NC, A> DatafeedInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Datafeed) -> DatafeedInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Datafeed) -> DatafeedInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6878,7 +6874,7 @@ impl<'a, C, NC, A> DatafeedInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn merchant_id(mut self, new_value: &str) -> DatafeedInsertCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> DatafeedInsertCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -6889,7 +6885,7 @@ impl<'a, C, NC, A> DatafeedInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatafeedInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatafeedInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6910,7 +6906,7 @@ impl<'a, C, NC, A> DatafeedInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatafeedInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatafeedInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6927,7 +6923,7 @@ impl<'a, C, NC, A> DatafeedInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatafeedInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatafeedInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6967,10 +6963,10 @@ impl<'a, C, NC, A> DatafeedInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct DatafeedListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatafeedListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _merchant_id: String, _page_token: Option, _max_results: Option, @@ -6979,9 +6975,9 @@ pub struct DatafeedListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatafeedListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatafeedListCall<'a, C, A> {} -impl<'a, C, NC, A> DatafeedListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatafeedListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7119,7 +7115,7 @@ impl<'a, C, NC, A> DatafeedListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> DatafeedListCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> DatafeedListCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -7127,7 +7123,7 @@ impl<'a, C, NC, A> DatafeedListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> DatafeedListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> DatafeedListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -7135,7 +7131,7 @@ impl<'a, C, NC, A> DatafeedListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The maximum number of products to return in the response, used for paging. - pub fn max_results(mut self, new_value: u32) -> DatafeedListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> DatafeedListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -7146,7 +7142,7 @@ impl<'a, C, NC, A> DatafeedListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatafeedListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatafeedListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7167,7 +7163,7 @@ impl<'a, C, NC, A> DatafeedListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatafeedListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatafeedListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7184,7 +7180,7 @@ impl<'a, C, NC, A> DatafeedListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatafeedListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatafeedListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7228,10 +7224,10 @@ impl<'a, C, NC, A> DatafeedListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct DatafeedUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatafeedUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _request: Datafeed, _merchant_id: String, _datafeed_id: String, @@ -7240,9 +7236,9 @@ pub struct DatafeedUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatafeedUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatafeedUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> DatafeedUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatafeedUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7382,7 +7378,7 @@ impl<'a, C, NC, A> DatafeedUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Datafeed) -> DatafeedUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Datafeed) -> DatafeedUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7391,7 +7387,7 @@ impl<'a, C, NC, A> DatafeedUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn merchant_id(mut self, new_value: &str) -> DatafeedUpdateCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> DatafeedUpdateCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -7400,7 +7396,7 @@ impl<'a, C, NC, A> DatafeedUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn datafeed_id(mut self, new_value: &str) -> DatafeedUpdateCall<'a, C, NC, A> { + pub fn datafeed_id(mut self, new_value: &str) -> DatafeedUpdateCall<'a, C, A> { self._datafeed_id = new_value.to_string(); self } @@ -7411,7 +7407,7 @@ impl<'a, C, NC, A> DatafeedUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatafeedUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatafeedUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7432,7 +7428,7 @@ impl<'a, C, NC, A> DatafeedUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatafeedUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatafeedUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7449,7 +7445,7 @@ impl<'a, C, NC, A> DatafeedUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatafeedUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatafeedUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7487,10 +7483,10 @@ impl<'a, C, NC, A> DatafeedUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct ProductstatuseGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProductstatuseGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _merchant_id: String, _product_id: String, _delegate: Option<&'a mut Delegate>, @@ -7498,9 +7494,9 @@ pub struct ProductstatuseGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProductstatuseGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProductstatuseGetCall<'a, C, A> {} -impl<'a, C, NC, A> ProductstatuseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProductstatuseGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7633,7 +7629,7 @@ impl<'a, C, NC, A> ProductstatuseGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> ProductstatuseGetCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> ProductstatuseGetCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -7643,7 +7639,7 @@ impl<'a, C, NC, A> ProductstatuseGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the product. - pub fn product_id(mut self, new_value: &str) -> ProductstatuseGetCall<'a, C, NC, A> { + pub fn product_id(mut self, new_value: &str) -> ProductstatuseGetCall<'a, C, A> { self._product_id = new_value.to_string(); self } @@ -7654,7 +7650,7 @@ impl<'a, C, NC, A> ProductstatuseGetCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductstatuseGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductstatuseGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7675,7 +7671,7 @@ impl<'a, C, NC, A> ProductstatuseGetCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProductstatuseGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProductstatuseGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7692,7 +7688,7 @@ impl<'a, C, NC, A> ProductstatuseGetCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProductstatuseGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProductstatuseGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7732,10 +7728,10 @@ impl<'a, C, NC, A> ProductstatuseGetCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct ProductstatuseListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProductstatuseListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _merchant_id: String, _page_token: Option, _max_results: Option, @@ -7744,9 +7740,9 @@ pub struct ProductstatuseListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProductstatuseListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProductstatuseListCall<'a, C, A> {} -impl<'a, C, NC, A> ProductstatuseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProductstatuseListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7884,7 +7880,7 @@ impl<'a, C, NC, A> ProductstatuseListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> ProductstatuseListCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> ProductstatuseListCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -7892,7 +7888,7 @@ impl<'a, C, NC, A> ProductstatuseListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> ProductstatuseListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ProductstatuseListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -7900,7 +7896,7 @@ impl<'a, C, NC, A> ProductstatuseListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// The maximum number of product statuses to return in the response, used for paging. - pub fn max_results(mut self, new_value: u32) -> ProductstatuseListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> ProductstatuseListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -7911,7 +7907,7 @@ impl<'a, C, NC, A> ProductstatuseListCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductstatuseListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductstatuseListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7932,7 +7928,7 @@ impl<'a, C, NC, A> ProductstatuseListCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProductstatuseListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProductstatuseListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7949,7 +7945,7 @@ impl<'a, C, NC, A> ProductstatuseListCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProductstatuseListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProductstatuseListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7993,19 +7989,19 @@ impl<'a, C, NC, A> ProductstatuseListCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct ProductstatuseCustombatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProductstatuseCustombatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _request: ProductstatusesCustomBatchRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProductstatuseCustombatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProductstatuseCustombatchCall<'a, C, A> {} -impl<'a, C, NC, A> ProductstatuseCustombatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProductstatuseCustombatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8119,7 +8115,7 @@ impl<'a, C, NC, A> ProductstatuseCustombatchCall<'a, C, NC, A> where NC: hyper:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ProductstatusesCustomBatchRequest) -> ProductstatuseCustombatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ProductstatusesCustomBatchRequest) -> ProductstatuseCustombatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8130,7 +8126,7 @@ impl<'a, C, NC, A> ProductstatuseCustombatchCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductstatuseCustombatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductstatuseCustombatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8151,7 +8147,7 @@ impl<'a, C, NC, A> ProductstatuseCustombatchCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProductstatuseCustombatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProductstatuseCustombatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8168,7 +8164,7 @@ impl<'a, C, NC, A> ProductstatuseCustombatchCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProductstatuseCustombatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProductstatuseCustombatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8206,18 +8202,18 @@ impl<'a, C, NC, A> ProductstatuseCustombatchCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct AccountAuthinfoCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountAuthinfoCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountAuthinfoCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountAuthinfoCall<'a, C, A> {} -impl<'a, C, NC, A> AccountAuthinfoCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountAuthinfoCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8325,7 +8321,7 @@ impl<'a, C, NC, A> AccountAuthinfoCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAuthinfoCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountAuthinfoCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8346,7 +8342,7 @@ impl<'a, C, NC, A> AccountAuthinfoCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountAuthinfoCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountAuthinfoCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8363,7 +8359,7 @@ impl<'a, C, NC, A> AccountAuthinfoCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountAuthinfoCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountAuthinfoCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8407,10 +8403,10 @@ impl<'a, C, NC, A> AccountAuthinfoCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct AccountPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _request: Account, _merchant_id: String, _account_id: String, @@ -8419,9 +8415,9 @@ pub struct AccountPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountPatchCall<'a, C, A> {} -impl<'a, C, NC, A> AccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8561,7 +8557,7 @@ impl<'a, C, NC, A> AccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Account) -> AccountPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Account) -> AccountPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8571,7 +8567,7 @@ impl<'a, C, NC, A> AccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> AccountPatchCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> AccountPatchCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -8581,7 +8577,7 @@ impl<'a, C, NC, A> AccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the account. - pub fn account_id(mut self, new_value: &str) -> AccountPatchCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountPatchCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -8592,7 +8588,7 @@ impl<'a, C, NC, A> AccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8613,7 +8609,7 @@ impl<'a, C, NC, A> AccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8630,7 +8626,7 @@ impl<'a, C, NC, A> AccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8668,10 +8664,10 @@ impl<'a, C, NC, A> AccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct AccountGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _merchant_id: String, _account_id: String, _delegate: Option<&'a mut Delegate>, @@ -8679,9 +8675,9 @@ pub struct AccountGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8814,7 +8810,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> AccountGetCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> AccountGetCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -8824,7 +8820,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the account. - pub fn account_id(mut self, new_value: &str) -> AccountGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -8835,7 +8831,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8856,7 +8852,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8873,7 +8869,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8917,10 +8913,10 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct AccountUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _request: Account, _merchant_id: String, _account_id: String, @@ -8929,9 +8925,9 @@ pub struct AccountUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9071,7 +9067,7 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Account) -> AccountUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Account) -> AccountUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9081,7 +9077,7 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> AccountUpdateCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> AccountUpdateCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -9091,7 +9087,7 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the account. - pub fn account_id(mut self, new_value: &str) -> AccountUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -9102,7 +9098,7 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9123,7 +9119,7 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9140,7 +9136,7 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9180,10 +9176,10 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct AccountListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _merchant_id: String, _page_token: Option, _max_results: Option, @@ -9192,9 +9188,9 @@ pub struct AccountListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9332,7 +9328,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> AccountListCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> AccountListCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -9340,7 +9336,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> AccountListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AccountListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -9348,7 +9344,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The maximum number of accounts to return in the response, used for paging. - pub fn max_results(mut self, new_value: u32) -> AccountListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> AccountListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -9359,7 +9355,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9380,7 +9376,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9397,7 +9393,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9435,10 +9431,10 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct AccountDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _merchant_id: String, _account_id: String, _delegate: Option<&'a mut Delegate>, @@ -9446,9 +9442,9 @@ pub struct AccountDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> AccountDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9570,7 +9566,7 @@ impl<'a, C, NC, A> AccountDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> AccountDeleteCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> AccountDeleteCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -9580,7 +9576,7 @@ impl<'a, C, NC, A> AccountDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the account. - pub fn account_id(mut self, new_value: &str) -> AccountDeleteCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountDeleteCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -9591,7 +9587,7 @@ impl<'a, C, NC, A> AccountDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9612,7 +9608,7 @@ impl<'a, C, NC, A> AccountDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9629,7 +9625,7 @@ impl<'a, C, NC, A> AccountDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9673,19 +9669,19 @@ impl<'a, C, NC, A> AccountDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct AccountCustombatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountCustombatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _request: AccountsCustomBatchRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountCustombatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountCustombatchCall<'a, C, A> {} -impl<'a, C, NC, A> AccountCustombatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountCustombatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9799,7 +9795,7 @@ impl<'a, C, NC, A> AccountCustombatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AccountsCustomBatchRequest) -> AccountCustombatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AccountsCustomBatchRequest) -> AccountCustombatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9810,7 +9806,7 @@ impl<'a, C, NC, A> AccountCustombatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountCustombatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountCustombatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9831,7 +9827,7 @@ impl<'a, C, NC, A> AccountCustombatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountCustombatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountCustombatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9848,7 +9844,7 @@ impl<'a, C, NC, A> AccountCustombatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountCustombatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountCustombatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9892,10 +9888,10 @@ impl<'a, C, NC, A> AccountCustombatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct AccountInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _request: Account, _merchant_id: String, _delegate: Option<&'a mut Delegate>, @@ -9903,9 +9899,9 @@ pub struct AccountInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountInsertCall<'a, C, A> {} -impl<'a, C, NC, A> AccountInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10044,7 +10040,7 @@ impl<'a, C, NC, A> AccountInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Account) -> AccountInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Account) -> AccountInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -10054,7 +10050,7 @@ impl<'a, C, NC, A> AccountInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> AccountInsertCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> AccountInsertCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -10065,7 +10061,7 @@ impl<'a, C, NC, A> AccountInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10086,7 +10082,7 @@ impl<'a, C, NC, A> AccountInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10103,7 +10099,7 @@ impl<'a, C, NC, A> AccountInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10147,10 +10143,10 @@ impl<'a, C, NC, A> AccountInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct InventorySetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InventorySetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _request: InventorySetRequest, _merchant_id: String, _store_code: String, @@ -10160,9 +10156,9 @@ pub struct InventorySetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InventorySetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InventorySetCall<'a, C, A> {} -impl<'a, C, NC, A> InventorySetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InventorySetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10303,7 +10299,7 @@ impl<'a, C, NC, A> InventorySetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &InventorySetRequest) -> InventorySetCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &InventorySetRequest) -> InventorySetCall<'a, C, A> { self._request = new_value.clone(); self } @@ -10313,7 +10309,7 @@ impl<'a, C, NC, A> InventorySetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> InventorySetCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> InventorySetCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -10323,7 +10319,7 @@ impl<'a, C, NC, A> InventorySetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The code of the store for which to update price and availability. Use online to update price and availability of an online product. - pub fn store_code(mut self, new_value: &str) -> InventorySetCall<'a, C, NC, A> { + pub fn store_code(mut self, new_value: &str) -> InventorySetCall<'a, C, A> { self._store_code = new_value.to_string(); self } @@ -10333,7 +10329,7 @@ impl<'a, C, NC, A> InventorySetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the product for which to update price and availability. - pub fn product_id(mut self, new_value: &str) -> InventorySetCall<'a, C, NC, A> { + pub fn product_id(mut self, new_value: &str) -> InventorySetCall<'a, C, A> { self._product_id = new_value.to_string(); self } @@ -10344,7 +10340,7 @@ impl<'a, C, NC, A> InventorySetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InventorySetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InventorySetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10365,7 +10361,7 @@ impl<'a, C, NC, A> InventorySetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InventorySetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InventorySetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10382,7 +10378,7 @@ impl<'a, C, NC, A> InventorySetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InventorySetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InventorySetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10426,19 +10422,19 @@ impl<'a, C, NC, A> InventorySetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct InventoryCustombatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InventoryCustombatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _request: InventoryCustomBatchRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InventoryCustombatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InventoryCustombatchCall<'a, C, A> {} -impl<'a, C, NC, A> InventoryCustombatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InventoryCustombatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10552,7 +10548,7 @@ impl<'a, C, NC, A> InventoryCustombatchCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &InventoryCustomBatchRequest) -> InventoryCustombatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &InventoryCustomBatchRequest) -> InventoryCustombatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -10563,7 +10559,7 @@ impl<'a, C, NC, A> InventoryCustombatchCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InventoryCustombatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InventoryCustombatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10584,7 +10580,7 @@ impl<'a, C, NC, A> InventoryCustombatchCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InventoryCustombatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InventoryCustombatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10601,7 +10597,7 @@ impl<'a, C, NC, A> InventoryCustombatchCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InventoryCustombatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InventoryCustombatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10639,10 +10635,10 @@ impl<'a, C, NC, A> InventoryCustombatchCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct AccountstatuseGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountstatuseGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _merchant_id: String, _account_id: String, _delegate: Option<&'a mut Delegate>, @@ -10650,9 +10646,9 @@ pub struct AccountstatuseGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountstatuseGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountstatuseGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountstatuseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountstatuseGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10785,7 +10781,7 @@ impl<'a, C, NC, A> AccountstatuseGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> AccountstatuseGetCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> AccountstatuseGetCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -10795,7 +10791,7 @@ impl<'a, C, NC, A> AccountstatuseGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the account. - pub fn account_id(mut self, new_value: &str) -> AccountstatuseGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountstatuseGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -10806,7 +10802,7 @@ impl<'a, C, NC, A> AccountstatuseGetCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountstatuseGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountstatuseGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10827,7 +10823,7 @@ impl<'a, C, NC, A> AccountstatuseGetCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountstatuseGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountstatuseGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10844,7 +10840,7 @@ impl<'a, C, NC, A> AccountstatuseGetCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountstatuseGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountstatuseGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10884,10 +10880,10 @@ impl<'a, C, NC, A> AccountstatuseGetCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct AccountstatuseListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountstatuseListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _merchant_id: String, _page_token: Option, _max_results: Option, @@ -10896,9 +10892,9 @@ pub struct AccountstatuseListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountstatuseListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountstatuseListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountstatuseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountstatuseListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11036,7 +11032,7 @@ impl<'a, C, NC, A> AccountstatuseListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> AccountstatuseListCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> AccountstatuseListCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -11044,7 +11040,7 @@ impl<'a, C, NC, A> AccountstatuseListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> AccountstatuseListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AccountstatuseListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -11052,7 +11048,7 @@ impl<'a, C, NC, A> AccountstatuseListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// The maximum number of account statuses to return in the response, used for paging. - pub fn max_results(mut self, new_value: u32) -> AccountstatuseListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> AccountstatuseListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -11063,7 +11059,7 @@ impl<'a, C, NC, A> AccountstatuseListCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountstatuseListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountstatuseListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11084,7 +11080,7 @@ impl<'a, C, NC, A> AccountstatuseListCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountstatuseListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountstatuseListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11101,7 +11097,7 @@ impl<'a, C, NC, A> AccountstatuseListCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountstatuseListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountstatuseListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11143,19 +11139,19 @@ impl<'a, C, NC, A> AccountstatuseListCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct AccountstatuseCustombatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountstatuseCustombatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _request: AccountstatusesCustomBatchRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountstatuseCustombatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountstatuseCustombatchCall<'a, C, A> {} -impl<'a, C, NC, A> AccountstatuseCustombatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountstatuseCustombatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11269,7 +11265,7 @@ impl<'a, C, NC, A> AccountstatuseCustombatchCall<'a, C, NC, A> where NC: hyper:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AccountstatusesCustomBatchRequest) -> AccountstatuseCustombatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AccountstatusesCustomBatchRequest) -> AccountstatuseCustombatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -11280,7 +11276,7 @@ impl<'a, C, NC, A> AccountstatuseCustombatchCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountstatuseCustombatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountstatuseCustombatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11301,7 +11297,7 @@ impl<'a, C, NC, A> AccountstatuseCustombatchCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountstatuseCustombatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountstatuseCustombatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11318,7 +11314,7 @@ impl<'a, C, NC, A> AccountstatuseCustombatchCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountstatuseCustombatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountstatuseCustombatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11358,10 +11354,10 @@ impl<'a, C, NC, A> AccountstatuseCustombatchCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct ProductListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProductListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _merchant_id: String, _page_token: Option, _max_results: Option, @@ -11370,9 +11366,9 @@ pub struct ProductListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProductListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProductListCall<'a, C, A> {} -impl<'a, C, NC, A> ProductListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProductListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11510,7 +11506,7 @@ impl<'a, C, NC, A> ProductListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> ProductListCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> ProductListCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -11518,7 +11514,7 @@ impl<'a, C, NC, A> ProductListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> ProductListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ProductListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -11526,7 +11522,7 @@ impl<'a, C, NC, A> ProductListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The maximum number of products to return in the response, used for paging. - pub fn max_results(mut self, new_value: u32) -> ProductListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> ProductListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -11537,7 +11533,7 @@ impl<'a, C, NC, A> ProductListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11558,7 +11554,7 @@ impl<'a, C, NC, A> ProductListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProductListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProductListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11575,7 +11571,7 @@ impl<'a, C, NC, A> ProductListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProductListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProductListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11613,10 +11609,10 @@ impl<'a, C, NC, A> ProductListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct ProductGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProductGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _merchant_id: String, _product_id: String, _delegate: Option<&'a mut Delegate>, @@ -11624,9 +11620,9 @@ pub struct ProductGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProductGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProductGetCall<'a, C, A> {} -impl<'a, C, NC, A> ProductGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProductGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11759,7 +11755,7 @@ impl<'a, C, NC, A> ProductGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> ProductGetCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> ProductGetCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -11769,7 +11765,7 @@ impl<'a, C, NC, A> ProductGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the product. - pub fn product_id(mut self, new_value: &str) -> ProductGetCall<'a, C, NC, A> { + pub fn product_id(mut self, new_value: &str) -> ProductGetCall<'a, C, A> { self._product_id = new_value.to_string(); self } @@ -11780,7 +11776,7 @@ impl<'a, C, NC, A> ProductGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11801,7 +11797,7 @@ impl<'a, C, NC, A> ProductGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProductGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProductGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11818,7 +11814,7 @@ impl<'a, C, NC, A> ProductGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProductGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProductGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11857,10 +11853,10 @@ impl<'a, C, NC, A> ProductGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct ProductDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProductDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _merchant_id: String, _product_id: String, _dry_run: Option, @@ -11869,9 +11865,9 @@ pub struct ProductDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProductDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProductDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ProductDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProductDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11996,7 +11992,7 @@ impl<'a, C, NC, A> ProductDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> ProductDeleteCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> ProductDeleteCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -12006,7 +12002,7 @@ impl<'a, C, NC, A> ProductDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the product. - pub fn product_id(mut self, new_value: &str) -> ProductDeleteCall<'a, C, NC, A> { + pub fn product_id(mut self, new_value: &str) -> ProductDeleteCall<'a, C, A> { self._product_id = new_value.to_string(); self } @@ -12014,7 +12010,7 @@ impl<'a, C, NC, A> ProductDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Flag to run the request in dry-run mode. - pub fn dry_run(mut self, new_value: bool) -> ProductDeleteCall<'a, C, NC, A> { + pub fn dry_run(mut self, new_value: bool) -> ProductDeleteCall<'a, C, A> { self._dry_run = Some(new_value); self } @@ -12025,7 +12021,7 @@ impl<'a, C, NC, A> ProductDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12046,7 +12042,7 @@ impl<'a, C, NC, A> ProductDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProductDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProductDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12063,7 +12059,7 @@ impl<'a, C, NC, A> ProductDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProductDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProductDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12108,10 +12104,10 @@ impl<'a, C, NC, A> ProductDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct ProductCustombatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProductCustombatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _request: ProductsCustomBatchRequest, _dry_run: Option, _delegate: Option<&'a mut Delegate>, @@ -12119,9 +12115,9 @@ pub struct ProductCustombatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProductCustombatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProductCustombatchCall<'a, C, A> {} -impl<'a, C, NC, A> ProductCustombatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProductCustombatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12238,7 +12234,7 @@ impl<'a, C, NC, A> ProductCustombatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ProductsCustomBatchRequest) -> ProductCustombatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ProductsCustomBatchRequest) -> ProductCustombatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -12246,7 +12242,7 @@ impl<'a, C, NC, A> ProductCustombatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Flag to run the request in dry-run mode. - pub fn dry_run(mut self, new_value: bool) -> ProductCustombatchCall<'a, C, NC, A> { + pub fn dry_run(mut self, new_value: bool) -> ProductCustombatchCall<'a, C, A> { self._dry_run = Some(new_value); self } @@ -12257,7 +12253,7 @@ impl<'a, C, NC, A> ProductCustombatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductCustombatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductCustombatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12278,7 +12274,7 @@ impl<'a, C, NC, A> ProductCustombatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProductCustombatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProductCustombatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12295,7 +12291,7 @@ impl<'a, C, NC, A> ProductCustombatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProductCustombatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProductCustombatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12340,10 +12336,10 @@ impl<'a, C, NC, A> ProductCustombatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct ProductInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProductInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _request: Product, _merchant_id: String, _dry_run: Option, @@ -12352,9 +12348,9 @@ pub struct ProductInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProductInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProductInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ProductInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProductInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12496,7 +12492,7 @@ impl<'a, C, NC, A> ProductInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Product) -> ProductInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Product) -> ProductInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -12506,7 +12502,7 @@ impl<'a, C, NC, A> ProductInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> ProductInsertCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> ProductInsertCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -12514,7 +12510,7 @@ impl<'a, C, NC, A> ProductInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Flag to run the request in dry-run mode. - pub fn dry_run(mut self, new_value: bool) -> ProductInsertCall<'a, C, NC, A> { + pub fn dry_run(mut self, new_value: bool) -> ProductInsertCall<'a, C, A> { self._dry_run = Some(new_value); self } @@ -12525,7 +12521,7 @@ impl<'a, C, NC, A> ProductInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProductInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12546,7 +12542,7 @@ impl<'a, C, NC, A> ProductInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProductInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProductInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12563,7 +12559,7 @@ impl<'a, C, NC, A> ProductInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProductInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProductInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12603,10 +12599,10 @@ impl<'a, C, NC, A> ProductInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct AccountshippingListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountshippingListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _merchant_id: String, _page_token: Option, _max_results: Option, @@ -12615,9 +12611,9 @@ pub struct AccountshippingListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountshippingListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountshippingListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountshippingListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountshippingListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12755,7 +12751,7 @@ impl<'a, C, NC, A> AccountshippingListCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> AccountshippingListCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> AccountshippingListCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -12763,7 +12759,7 @@ impl<'a, C, NC, A> AccountshippingListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> AccountshippingListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AccountshippingListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -12771,7 +12767,7 @@ impl<'a, C, NC, A> AccountshippingListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The maximum number of shipping settings to return in the response, used for paging. - pub fn max_results(mut self, new_value: u32) -> AccountshippingListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> AccountshippingListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -12782,7 +12778,7 @@ impl<'a, C, NC, A> AccountshippingListCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountshippingListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountshippingListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12803,7 +12799,7 @@ impl<'a, C, NC, A> AccountshippingListCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountshippingListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountshippingListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12820,7 +12816,7 @@ impl<'a, C, NC, A> AccountshippingListCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountshippingListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountshippingListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12864,10 +12860,10 @@ impl<'a, C, NC, A> AccountshippingListCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct AccountshippingPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountshippingPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _request: AccountShipping, _merchant_id: String, _account_id: String, @@ -12876,9 +12872,9 @@ pub struct AccountshippingPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountshippingPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountshippingPatchCall<'a, C, A> {} -impl<'a, C, NC, A> AccountshippingPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountshippingPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13018,7 +13014,7 @@ impl<'a, C, NC, A> AccountshippingPatchCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AccountShipping) -> AccountshippingPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AccountShipping) -> AccountshippingPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13028,7 +13024,7 @@ impl<'a, C, NC, A> AccountshippingPatchCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> AccountshippingPatchCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> AccountshippingPatchCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -13038,7 +13034,7 @@ impl<'a, C, NC, A> AccountshippingPatchCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The ID of the account for which to get/update account shipping settings. - pub fn account_id(mut self, new_value: &str) -> AccountshippingPatchCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountshippingPatchCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -13049,7 +13045,7 @@ impl<'a, C, NC, A> AccountshippingPatchCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountshippingPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountshippingPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13070,7 +13066,7 @@ impl<'a, C, NC, A> AccountshippingPatchCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountshippingPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountshippingPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13087,7 +13083,7 @@ impl<'a, C, NC, A> AccountshippingPatchCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountshippingPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountshippingPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13131,10 +13127,10 @@ impl<'a, C, NC, A> AccountshippingPatchCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct AccountshippingUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountshippingUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _request: AccountShipping, _merchant_id: String, _account_id: String, @@ -13143,9 +13139,9 @@ pub struct AccountshippingUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountshippingUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountshippingUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountshippingUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountshippingUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13285,7 +13281,7 @@ impl<'a, C, NC, A> AccountshippingUpdateCall<'a, C, NC, A> where NC: hyper::net: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AccountShipping) -> AccountshippingUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AccountShipping) -> AccountshippingUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13295,7 +13291,7 @@ impl<'a, C, NC, A> AccountshippingUpdateCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> AccountshippingUpdateCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> AccountshippingUpdateCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -13305,7 +13301,7 @@ impl<'a, C, NC, A> AccountshippingUpdateCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The ID of the account for which to get/update account shipping settings. - pub fn account_id(mut self, new_value: &str) -> AccountshippingUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountshippingUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -13316,7 +13312,7 @@ impl<'a, C, NC, A> AccountshippingUpdateCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountshippingUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountshippingUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13337,7 +13333,7 @@ impl<'a, C, NC, A> AccountshippingUpdateCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountshippingUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountshippingUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13354,7 +13350,7 @@ impl<'a, C, NC, A> AccountshippingUpdateCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountshippingUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountshippingUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13398,19 +13394,19 @@ impl<'a, C, NC, A> AccountshippingUpdateCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct AccountshippingCustombatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountshippingCustombatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _request: AccountshippingCustomBatchRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountshippingCustombatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountshippingCustombatchCall<'a, C, A> {} -impl<'a, C, NC, A> AccountshippingCustombatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountshippingCustombatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13524,7 +13520,7 @@ impl<'a, C, NC, A> AccountshippingCustombatchCall<'a, C, NC, A> where NC: hyper: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AccountshippingCustomBatchRequest) -> AccountshippingCustombatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AccountshippingCustomBatchRequest) -> AccountshippingCustombatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13535,7 +13531,7 @@ impl<'a, C, NC, A> AccountshippingCustombatchCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountshippingCustombatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountshippingCustombatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13556,7 +13552,7 @@ impl<'a, C, NC, A> AccountshippingCustombatchCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountshippingCustombatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountshippingCustombatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13573,7 +13569,7 @@ impl<'a, C, NC, A> AccountshippingCustombatchCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountshippingCustombatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountshippingCustombatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13611,10 +13607,10 @@ impl<'a, C, NC, A> AccountshippingCustombatchCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct AccountshippingGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountshippingGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a ShoppingContent, + hub: &'a ShoppingContent, _merchant_id: String, _account_id: String, _delegate: Option<&'a mut Delegate>, @@ -13622,9 +13618,9 @@ pub struct AccountshippingGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountshippingGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountshippingGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountshippingGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountshippingGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13757,7 +13753,7 @@ impl<'a, C, NC, A> AccountshippingGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The ID of the managing account. - pub fn merchant_id(mut self, new_value: &str) -> AccountshippingGetCall<'a, C, NC, A> { + pub fn merchant_id(mut self, new_value: &str) -> AccountshippingGetCall<'a, C, A> { self._merchant_id = new_value.to_string(); self } @@ -13767,7 +13763,7 @@ impl<'a, C, NC, A> AccountshippingGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The ID of the account for which to get/update account shipping settings. - pub fn account_id(mut self, new_value: &str) -> AccountshippingGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountshippingGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -13778,7 +13774,7 @@ impl<'a, C, NC, A> AccountshippingGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountshippingGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountshippingGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13799,7 +13795,7 @@ impl<'a, C, NC, A> AccountshippingGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountshippingGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountshippingGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13816,7 +13812,7 @@ impl<'a, C, NC, A> AccountshippingGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountshippingGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountshippingGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/coordinate1/Cargo.toml b/gen/coordinate1/Cargo.toml index 92201919fca..e6a61f3956f 100644 --- a/gen/coordinate1/Cargo.toml +++ b/gen/coordinate1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-coordinate1" -version = "0.1.4+20141215" +version = "0.1.5+20141215" authors = ["Sebastian Thiel "] description = "A complete library to interact with coordinate (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/coordinate1" homepage = "https://developers.google.com/coordinate/" -documentation = "http://byron.github.io/google-apis-rs/google-coordinate1" +documentation = "http://byron.github.io/google-apis-rs/google_coordinate1" license = "MIT" keywords = ["coordinate", "google", "protocol", "web", "api"] diff --git a/gen/coordinate1/README.md b/gen/coordinate1/README.md index da4bb468f40..4d7dc617a33 100644 --- a/gen/coordinate1/README.md +++ b/gen/coordinate1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-coordinate1` library allows access to all features of the *Google coordinate* service. -This documentation was generated from *coordinate* crate version *0.1.4+20141215*, where *20141215* is the exact revision of the *coordinate:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *coordinate* crate version *0.1.5+20141215*, where *20141215* is the exact revision of the *coordinate:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *coordinate* *v1* API can be found at the [official documentation site](https://developers.google.com/coordinate/). diff --git a/gen/coordinate1/src/cmn.rs b/gen/coordinate1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/coordinate1/src/cmn.rs +++ b/gen/coordinate1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/coordinate1/src/lib.rs b/gen/coordinate1/src/lib.rs index edd3b08faa7..9b388e1cce3 100644 --- a/gen/coordinate1/src/lib.rs +++ b/gen/coordinate1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *coordinate* crate version *0.1.4+20141215*, where *20141215* is the exact revision of the *coordinate:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *coordinate* crate version *0.1.5+20141215*, where *20141215* is the exact revision of the *coordinate:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *coordinate* *v1* API can be found at the //! [official documentation site](https://developers.google.com/coordinate/). @@ -218,7 +218,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -329,49 +328,46 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Coordinate { +pub struct Coordinate { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Coordinate {} +impl<'a, C, A> Hub for Coordinate {} -impl<'a, C, NC, A> Coordinate - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Coordinate + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Coordinate { + pub fn new(client: C, authenticator: A) -> Coordinate { Coordinate { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn custom_field_def(&'a self) -> CustomFieldDefMethods<'a, C, NC, A> { + pub fn custom_field_def(&'a self) -> CustomFieldDefMethods<'a, C, A> { CustomFieldDefMethods { hub: &self } } - pub fn jobs(&'a self) -> JobMethods<'a, C, NC, A> { + pub fn jobs(&'a self) -> JobMethods<'a, C, A> { JobMethods { hub: &self } } - pub fn location(&'a self) -> LocationMethods<'a, C, NC, A> { + pub fn location(&'a self) -> LocationMethods<'a, C, A> { LocationMethods { hub: &self } } - pub fn schedule(&'a self) -> ScheduleMethods<'a, C, NC, A> { + pub fn schedule(&'a self) -> ScheduleMethods<'a, C, A> { ScheduleMethods { hub: &self } } - pub fn team(&'a self) -> TeamMethods<'a, C, NC, A> { + pub fn team(&'a self) -> TeamMethods<'a, C, A> { TeamMethods { hub: &self } } - pub fn worker(&'a self) -> WorkerMethods<'a, C, NC, A> { + pub fn worker(&'a self) -> WorkerMethods<'a, C, A> { WorkerMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -811,15 +807,15 @@ impl Part for CustomField {} /// let rb = hub.jobs(); /// # } /// ``` -pub struct JobMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct JobMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Coordinate, + hub: &'a Coordinate, } -impl<'a, C, NC, A> MethodsBuilder for JobMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for JobMethods<'a, C, A> {} -impl<'a, C, NC, A> JobMethods<'a, C, NC, A> { +impl<'a, C, A> JobMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -829,7 +825,7 @@ impl<'a, C, NC, A> JobMethods<'a, C, NC, A> { /// /// * `teamId` - Team ID /// * `jobId` - Job number - pub fn get(&self, team_id: &str, job_id: &str) -> JobGetCall<'a, C, NC, A> { + pub fn get(&self, team_id: &str, job_id: &str) -> JobGetCall<'a, C, A> { JobGetCall { hub: self.hub, _team_id: team_id.to_string(), @@ -849,7 +845,7 @@ impl<'a, C, NC, A> JobMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `teamId` - Team ID /// * `jobId` - Job number - pub fn update(&self, request: &Job, team_id: &str, job_id: &str) -> JobUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Job, team_id: &str, job_id: &str) -> JobUpdateCall<'a, C, A> { JobUpdateCall { hub: self.hub, _request: request.clone(), @@ -880,7 +876,7 @@ impl<'a, C, NC, A> JobMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `teamId` - Team ID /// * `jobId` - Job number - pub fn patch(&self, request: &Job, team_id: &str, job_id: &str) -> JobPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Job, team_id: &str, job_id: &str) -> JobPatchCall<'a, C, A> { JobPatchCall { hub: self.hub, _request: request.clone(), @@ -909,7 +905,7 @@ impl<'a, C, NC, A> JobMethods<'a, C, NC, A> { /// # Arguments /// /// * `teamId` - Team ID - pub fn list(&self, team_id: &str) -> JobListCall<'a, C, NC, A> { + pub fn list(&self, team_id: &str) -> JobListCall<'a, C, A> { JobListCall { hub: self.hub, _team_id: team_id.to_string(), @@ -934,7 +930,7 @@ impl<'a, C, NC, A> JobMethods<'a, C, NC, A> { /// * `lat` - The latitude coordinate of this job's location. /// * `lng` - The longitude coordinate of this job's location. /// * `title` - Job title - pub fn insert(&self, request: &Job, team_id: &str, address: &str, lat: f64, lng: f64, title: &str) -> JobInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Job, team_id: &str, address: &str, lat: f64, lng: f64, title: &str) -> JobInsertCall<'a, C, A> { JobInsertCall { hub: self.hub, _request: request.clone(), @@ -985,15 +981,15 @@ impl<'a, C, NC, A> JobMethods<'a, C, NC, A> { /// let rb = hub.schedule(); /// # } /// ``` -pub struct ScheduleMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ScheduleMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Coordinate, + hub: &'a Coordinate, } -impl<'a, C, NC, A> MethodsBuilder for ScheduleMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ScheduleMethods<'a, C, A> {} -impl<'a, C, NC, A> ScheduleMethods<'a, C, NC, A> { +impl<'a, C, A> ScheduleMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1004,7 +1000,7 @@ impl<'a, C, NC, A> ScheduleMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `teamId` - Team ID /// * `jobId` - Job number - pub fn update(&self, request: &Schedule, team_id: &str, job_id: &str) -> ScheduleUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Schedule, team_id: &str, job_id: &str) -> ScheduleUpdateCall<'a, C, A> { ScheduleUpdateCall { hub: self.hub, _request: request.clone(), @@ -1029,7 +1025,7 @@ impl<'a, C, NC, A> ScheduleMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `teamId` - Team ID /// * `jobId` - Job number - pub fn patch(&self, request: &Schedule, team_id: &str, job_id: &str) -> SchedulePatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Schedule, team_id: &str, job_id: &str) -> SchedulePatchCall<'a, C, A> { SchedulePatchCall { hub: self.hub, _request: request.clone(), @@ -1053,7 +1049,7 @@ impl<'a, C, NC, A> ScheduleMethods<'a, C, NC, A> { /// /// * `teamId` - Team ID /// * `jobId` - Job number - pub fn get(&self, team_id: &str, job_id: &str) -> ScheduleGetCall<'a, C, NC, A> { + pub fn get(&self, team_id: &str, job_id: &str) -> ScheduleGetCall<'a, C, A> { ScheduleGetCall { hub: self.hub, _team_id: team_id.to_string(), @@ -1095,15 +1091,15 @@ impl<'a, C, NC, A> ScheduleMethods<'a, C, NC, A> { /// let rb = hub.worker(); /// # } /// ``` -pub struct WorkerMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct WorkerMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Coordinate, + hub: &'a Coordinate, } -impl<'a, C, NC, A> MethodsBuilder for WorkerMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for WorkerMethods<'a, C, A> {} -impl<'a, C, NC, A> WorkerMethods<'a, C, NC, A> { +impl<'a, C, A> WorkerMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1112,7 +1108,7 @@ impl<'a, C, NC, A> WorkerMethods<'a, C, NC, A> { /// # Arguments /// /// * `teamId` - Team ID - pub fn list(&self, team_id: &str) -> WorkerListCall<'a, C, NC, A> { + pub fn list(&self, team_id: &str) -> WorkerListCall<'a, C, A> { WorkerListCall { hub: self.hub, _team_id: team_id.to_string(), @@ -1153,15 +1149,15 @@ impl<'a, C, NC, A> WorkerMethods<'a, C, NC, A> { /// let rb = hub.location(); /// # } /// ``` -pub struct LocationMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LocationMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Coordinate, + hub: &'a Coordinate, } -impl<'a, C, NC, A> MethodsBuilder for LocationMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for LocationMethods<'a, C, A> {} -impl<'a, C, NC, A> LocationMethods<'a, C, NC, A> { +impl<'a, C, A> LocationMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1172,7 +1168,7 @@ impl<'a, C, NC, A> LocationMethods<'a, C, NC, A> { /// * `teamId` - Team ID /// * `workerEmail` - Worker email address. /// * `startTimestampMs` - Start timestamp in milliseconds since the epoch. - pub fn list(&self, team_id: &str, worker_email: &str, start_timestamp_ms: &str) -> LocationListCall<'a, C, NC, A> { + pub fn list(&self, team_id: &str, worker_email: &str, start_timestamp_ms: &str) -> LocationListCall<'a, C, A> { LocationListCall { hub: self.hub, _team_id: team_id.to_string(), @@ -1217,20 +1213,20 @@ impl<'a, C, NC, A> LocationMethods<'a, C, NC, A> { /// let rb = hub.team(); /// # } /// ``` -pub struct TeamMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TeamMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Coordinate, + hub: &'a Coordinate, } -impl<'a, C, NC, A> MethodsBuilder for TeamMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TeamMethods<'a, C, A> {} -impl<'a, C, NC, A> TeamMethods<'a, C, NC, A> { +impl<'a, C, A> TeamMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Retrieves a list of teams for a user. - pub fn list(&self) -> TeamListCall<'a, C, NC, A> { + pub fn list(&self) -> TeamListCall<'a, C, A> { TeamListCall { hub: self.hub, _worker: Default::default(), @@ -1273,15 +1269,15 @@ impl<'a, C, NC, A> TeamMethods<'a, C, NC, A> { /// let rb = hub.custom_field_def(); /// # } /// ``` -pub struct CustomFieldDefMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CustomFieldDefMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Coordinate, + hub: &'a Coordinate, } -impl<'a, C, NC, A> MethodsBuilder for CustomFieldDefMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CustomFieldDefMethods<'a, C, A> {} -impl<'a, C, NC, A> CustomFieldDefMethods<'a, C, NC, A> { +impl<'a, C, A> CustomFieldDefMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1290,7 +1286,7 @@ impl<'a, C, NC, A> CustomFieldDefMethods<'a, C, NC, A> { /// # Arguments /// /// * `teamId` - Team ID - pub fn list(&self, team_id: &str) -> CustomFieldDefListCall<'a, C, NC, A> { + pub fn list(&self, team_id: &str) -> CustomFieldDefListCall<'a, C, A> { CustomFieldDefListCall { hub: self.hub, _team_id: team_id.to_string(), @@ -1339,10 +1335,10 @@ impl<'a, C, NC, A> CustomFieldDefMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct JobGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct JobGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Coordinate, + hub: &'a Coordinate, _team_id: String, _job_id: String, _delegate: Option<&'a mut Delegate>, @@ -1350,9 +1346,9 @@ pub struct JobGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for JobGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for JobGetCall<'a, C, A> {} -impl<'a, C, NC, A> JobGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> JobGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1485,7 +1481,7 @@ impl<'a, C, NC, A> JobGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// we provide this method for API completeness. /// /// Team ID - pub fn team_id(mut self, new_value: &str) -> JobGetCall<'a, C, NC, A> { + pub fn team_id(mut self, new_value: &str) -> JobGetCall<'a, C, A> { self._team_id = new_value.to_string(); self } @@ -1495,7 +1491,7 @@ impl<'a, C, NC, A> JobGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// we provide this method for API completeness. /// /// Job number - pub fn job_id(mut self, new_value: &str) -> JobGetCall<'a, C, NC, A> { + pub fn job_id(mut self, new_value: &str) -> JobGetCall<'a, C, A> { self._job_id = new_value.to_string(); self } @@ -1506,7 +1502,7 @@ impl<'a, C, NC, A> JobGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1527,7 +1523,7 @@ impl<'a, C, NC, A> JobGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> JobGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> JobGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1544,7 +1540,7 @@ impl<'a, C, NC, A> JobGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> JobGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> JobGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1598,10 +1594,10 @@ impl<'a, C, NC, A> JobGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// .doit(); /// # } /// ``` -pub struct JobUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct JobUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Coordinate, + hub: &'a Coordinate, _request: Job, _team_id: String, _job_id: String, @@ -1620,9 +1616,9 @@ pub struct JobUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for JobUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for JobUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> JobUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> JobUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1796,7 +1792,7 @@ impl<'a, C, NC, A> JobUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Job) -> JobUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Job) -> JobUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1806,7 +1802,7 @@ impl<'a, C, NC, A> JobUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Team ID - pub fn team_id(mut self, new_value: &str) -> JobUpdateCall<'a, C, NC, A> { + pub fn team_id(mut self, new_value: &str) -> JobUpdateCall<'a, C, A> { self._team_id = new_value.to_string(); self } @@ -1816,7 +1812,7 @@ impl<'a, C, NC, A> JobUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Job number - pub fn job_id(mut self, new_value: &str) -> JobUpdateCall<'a, C, NC, A> { + pub fn job_id(mut self, new_value: &str) -> JobUpdateCall<'a, C, A> { self._job_id = new_value.to_string(); self } @@ -1824,7 +1820,7 @@ impl<'a, C, NC, A> JobUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Job title - pub fn title(mut self, new_value: &str) -> JobUpdateCall<'a, C, NC, A> { + pub fn title(mut self, new_value: &str) -> JobUpdateCall<'a, C, A> { self._title = Some(new_value.to_string()); self } @@ -1832,7 +1828,7 @@ impl<'a, C, NC, A> JobUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Job progress - pub fn progress(mut self, new_value: &str) -> JobUpdateCall<'a, C, NC, A> { + pub fn progress(mut self, new_value: &str) -> JobUpdateCall<'a, C, A> { self._progress = Some(new_value.to_string()); self } @@ -1840,7 +1836,7 @@ impl<'a, C, NC, A> JobUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Job note as newline (Unix) separated string - pub fn note(mut self, new_value: &str) -> JobUpdateCall<'a, C, NC, A> { + pub fn note(mut self, new_value: &str) -> JobUpdateCall<'a, C, A> { self._note = Some(new_value.to_string()); self } @@ -1848,7 +1844,7 @@ impl<'a, C, NC, A> JobUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The longitude coordinate of this job's location. - pub fn lng(mut self, new_value: f64) -> JobUpdateCall<'a, C, NC, A> { + pub fn lng(mut self, new_value: f64) -> JobUpdateCall<'a, C, A> { self._lng = Some(new_value); self } @@ -1856,7 +1852,7 @@ impl<'a, C, NC, A> JobUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The latitude coordinate of this job's location. - pub fn lat(mut self, new_value: f64) -> JobUpdateCall<'a, C, NC, A> { + pub fn lat(mut self, new_value: f64) -> JobUpdateCall<'a, C, A> { self._lat = Some(new_value); self } @@ -1864,7 +1860,7 @@ impl<'a, C, NC, A> JobUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Customer phone number - pub fn customer_phone_number(mut self, new_value: &str) -> JobUpdateCall<'a, C, NC, A> { + pub fn customer_phone_number(mut self, new_value: &str) -> JobUpdateCall<'a, C, A> { self._customer_phone_number = Some(new_value.to_string()); self } @@ -1872,7 +1868,7 @@ impl<'a, C, NC, A> JobUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Customer name - pub fn customer_name(mut self, new_value: &str) -> JobUpdateCall<'a, C, NC, A> { + pub fn customer_name(mut self, new_value: &str) -> JobUpdateCall<'a, C, A> { self._customer_name = Some(new_value.to_string()); self } @@ -1881,7 +1877,7 @@ impl<'a, C, NC, A> JobUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Sets the value of custom fields. To set a custom field, pass the field id (from /team/teamId/custom_fields), a URL escaped '=' character, and the desired value as a parameter. For example, customField=12%3DAlice. Repeat the parameter for each custom field. Note that '=' cannot appear in the parameter value. Specifying an invalid, or inactive enum field will result in an error 500. - pub fn add_custom_field(mut self, new_value: &str) -> JobUpdateCall<'a, C, NC, A> { + pub fn add_custom_field(mut self, new_value: &str) -> JobUpdateCall<'a, C, A> { self._custom_field.push(new_value.to_string()); self } @@ -1889,7 +1885,7 @@ impl<'a, C, NC, A> JobUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Assignee email address, or empty string to unassign. - pub fn assignee(mut self, new_value: &str) -> JobUpdateCall<'a, C, NC, A> { + pub fn assignee(mut self, new_value: &str) -> JobUpdateCall<'a, C, A> { self._assignee = Some(new_value.to_string()); self } @@ -1897,7 +1893,7 @@ impl<'a, C, NC, A> JobUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Job address as newline (Unix) separated string - pub fn address(mut self, new_value: &str) -> JobUpdateCall<'a, C, NC, A> { + pub fn address(mut self, new_value: &str) -> JobUpdateCall<'a, C, A> { self._address = Some(new_value.to_string()); self } @@ -1908,7 +1904,7 @@ impl<'a, C, NC, A> JobUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1929,7 +1925,7 @@ impl<'a, C, NC, A> JobUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> JobUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> JobUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1946,7 +1942,7 @@ impl<'a, C, NC, A> JobUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> JobUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> JobUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2000,10 +1996,10 @@ impl<'a, C, NC, A> JobUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct JobPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct JobPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Coordinate, + hub: &'a Coordinate, _request: Job, _team_id: String, _job_id: String, @@ -2022,9 +2018,9 @@ pub struct JobPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for JobPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for JobPatchCall<'a, C, A> {} -impl<'a, C, NC, A> JobPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> JobPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2198,7 +2194,7 @@ impl<'a, C, NC, A> JobPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Job) -> JobPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Job) -> JobPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2208,7 +2204,7 @@ impl<'a, C, NC, A> JobPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Team ID - pub fn team_id(mut self, new_value: &str) -> JobPatchCall<'a, C, NC, A> { + pub fn team_id(mut self, new_value: &str) -> JobPatchCall<'a, C, A> { self._team_id = new_value.to_string(); self } @@ -2218,7 +2214,7 @@ impl<'a, C, NC, A> JobPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Job number - pub fn job_id(mut self, new_value: &str) -> JobPatchCall<'a, C, NC, A> { + pub fn job_id(mut self, new_value: &str) -> JobPatchCall<'a, C, A> { self._job_id = new_value.to_string(); self } @@ -2226,7 +2222,7 @@ impl<'a, C, NC, A> JobPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Job title - pub fn title(mut self, new_value: &str) -> JobPatchCall<'a, C, NC, A> { + pub fn title(mut self, new_value: &str) -> JobPatchCall<'a, C, A> { self._title = Some(new_value.to_string()); self } @@ -2234,7 +2230,7 @@ impl<'a, C, NC, A> JobPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Job progress - pub fn progress(mut self, new_value: &str) -> JobPatchCall<'a, C, NC, A> { + pub fn progress(mut self, new_value: &str) -> JobPatchCall<'a, C, A> { self._progress = Some(new_value.to_string()); self } @@ -2242,7 +2238,7 @@ impl<'a, C, NC, A> JobPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Job note as newline (Unix) separated string - pub fn note(mut self, new_value: &str) -> JobPatchCall<'a, C, NC, A> { + pub fn note(mut self, new_value: &str) -> JobPatchCall<'a, C, A> { self._note = Some(new_value.to_string()); self } @@ -2250,7 +2246,7 @@ impl<'a, C, NC, A> JobPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The longitude coordinate of this job's location. - pub fn lng(mut self, new_value: f64) -> JobPatchCall<'a, C, NC, A> { + pub fn lng(mut self, new_value: f64) -> JobPatchCall<'a, C, A> { self._lng = Some(new_value); self } @@ -2258,7 +2254,7 @@ impl<'a, C, NC, A> JobPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The latitude coordinate of this job's location. - pub fn lat(mut self, new_value: f64) -> JobPatchCall<'a, C, NC, A> { + pub fn lat(mut self, new_value: f64) -> JobPatchCall<'a, C, A> { self._lat = Some(new_value); self } @@ -2266,7 +2262,7 @@ impl<'a, C, NC, A> JobPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Customer phone number - pub fn customer_phone_number(mut self, new_value: &str) -> JobPatchCall<'a, C, NC, A> { + pub fn customer_phone_number(mut self, new_value: &str) -> JobPatchCall<'a, C, A> { self._customer_phone_number = Some(new_value.to_string()); self } @@ -2274,7 +2270,7 @@ impl<'a, C, NC, A> JobPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Customer name - pub fn customer_name(mut self, new_value: &str) -> JobPatchCall<'a, C, NC, A> { + pub fn customer_name(mut self, new_value: &str) -> JobPatchCall<'a, C, A> { self._customer_name = Some(new_value.to_string()); self } @@ -2283,7 +2279,7 @@ impl<'a, C, NC, A> JobPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Sets the value of custom fields. To set a custom field, pass the field id (from /team/teamId/custom_fields), a URL escaped '=' character, and the desired value as a parameter. For example, customField=12%3DAlice. Repeat the parameter for each custom field. Note that '=' cannot appear in the parameter value. Specifying an invalid, or inactive enum field will result in an error 500. - pub fn add_custom_field(mut self, new_value: &str) -> JobPatchCall<'a, C, NC, A> { + pub fn add_custom_field(mut self, new_value: &str) -> JobPatchCall<'a, C, A> { self._custom_field.push(new_value.to_string()); self } @@ -2291,7 +2287,7 @@ impl<'a, C, NC, A> JobPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Assignee email address, or empty string to unassign. - pub fn assignee(mut self, new_value: &str) -> JobPatchCall<'a, C, NC, A> { + pub fn assignee(mut self, new_value: &str) -> JobPatchCall<'a, C, A> { self._assignee = Some(new_value.to_string()); self } @@ -2299,7 +2295,7 @@ impl<'a, C, NC, A> JobPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Job address as newline (Unix) separated string - pub fn address(mut self, new_value: &str) -> JobPatchCall<'a, C, NC, A> { + pub fn address(mut self, new_value: &str) -> JobPatchCall<'a, C, A> { self._address = Some(new_value.to_string()); self } @@ -2310,7 +2306,7 @@ impl<'a, C, NC, A> JobPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2331,7 +2327,7 @@ impl<'a, C, NC, A> JobPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> JobPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> JobPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2348,7 +2344,7 @@ impl<'a, C, NC, A> JobPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> JobPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> JobPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2389,10 +2385,10 @@ impl<'a, C, NC, A> JobPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct JobListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct JobListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Coordinate, + hub: &'a Coordinate, _team_id: String, _page_token: Option, _min_modified_timestamp_ms: Option, @@ -2402,9 +2398,9 @@ pub struct JobListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for JobListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for JobListCall<'a, C, A> {} -impl<'a, C, NC, A> JobListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> JobListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2545,7 +2541,7 @@ impl<'a, C, NC, A> JobListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// Team ID - pub fn team_id(mut self, new_value: &str) -> JobListCall<'a, C, NC, A> { + pub fn team_id(mut self, new_value: &str) -> JobListCall<'a, C, A> { self._team_id = new_value.to_string(); self } @@ -2553,7 +2549,7 @@ impl<'a, C, NC, A> JobListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Continuation token - pub fn page_token(mut self, new_value: &str) -> JobListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> JobListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2561,7 +2557,7 @@ impl<'a, C, NC, A> JobListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Minimum time a job was modified in milliseconds since epoch. - pub fn min_modified_timestamp_ms(mut self, new_value: &str) -> JobListCall<'a, C, NC, A> { + pub fn min_modified_timestamp_ms(mut self, new_value: &str) -> JobListCall<'a, C, A> { self._min_modified_timestamp_ms = Some(new_value.to_string()); self } @@ -2569,7 +2565,7 @@ impl<'a, C, NC, A> JobListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Maximum number of results to return in one page. - pub fn max_results(mut self, new_value: u32) -> JobListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> JobListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2580,7 +2576,7 @@ impl<'a, C, NC, A> JobListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2601,7 +2597,7 @@ impl<'a, C, NC, A> JobListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> JobListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> JobListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2618,7 +2614,7 @@ impl<'a, C, NC, A> JobListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> JobListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> JobListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2667,10 +2663,10 @@ impl<'a, C, NC, A> JobListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct JobInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct JobInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Coordinate, + hub: &'a Coordinate, _request: Job, _team_id: String, _address: String, @@ -2687,9 +2683,9 @@ pub struct JobInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for JobInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for JobInsertCall<'a, C, A> {} -impl<'a, C, NC, A> JobInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> JobInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2851,7 +2847,7 @@ impl<'a, C, NC, A> JobInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Job) -> JobInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Job) -> JobInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2861,7 +2857,7 @@ impl<'a, C, NC, A> JobInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Team ID - pub fn team_id(mut self, new_value: &str) -> JobInsertCall<'a, C, NC, A> { + pub fn team_id(mut self, new_value: &str) -> JobInsertCall<'a, C, A> { self._team_id = new_value.to_string(); self } @@ -2871,7 +2867,7 @@ impl<'a, C, NC, A> JobInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Job address as newline (Unix) separated string - pub fn address(mut self, new_value: &str) -> JobInsertCall<'a, C, NC, A> { + pub fn address(mut self, new_value: &str) -> JobInsertCall<'a, C, A> { self._address = new_value.to_string(); self } @@ -2881,7 +2877,7 @@ impl<'a, C, NC, A> JobInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The latitude coordinate of this job's location. - pub fn lat(mut self, new_value: f64) -> JobInsertCall<'a, C, NC, A> { + pub fn lat(mut self, new_value: f64) -> JobInsertCall<'a, C, A> { self._lat = new_value; self } @@ -2891,7 +2887,7 @@ impl<'a, C, NC, A> JobInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The longitude coordinate of this job's location. - pub fn lng(mut self, new_value: f64) -> JobInsertCall<'a, C, NC, A> { + pub fn lng(mut self, new_value: f64) -> JobInsertCall<'a, C, A> { self._lng = new_value; self } @@ -2901,7 +2897,7 @@ impl<'a, C, NC, A> JobInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Job title - pub fn title(mut self, new_value: &str) -> JobInsertCall<'a, C, NC, A> { + pub fn title(mut self, new_value: &str) -> JobInsertCall<'a, C, A> { self._title = new_value.to_string(); self } @@ -2909,7 +2905,7 @@ impl<'a, C, NC, A> JobInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Job note as newline (Unix) separated string - pub fn note(mut self, new_value: &str) -> JobInsertCall<'a, C, NC, A> { + pub fn note(mut self, new_value: &str) -> JobInsertCall<'a, C, A> { self._note = Some(new_value.to_string()); self } @@ -2917,7 +2913,7 @@ impl<'a, C, NC, A> JobInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Customer phone number - pub fn customer_phone_number(mut self, new_value: &str) -> JobInsertCall<'a, C, NC, A> { + pub fn customer_phone_number(mut self, new_value: &str) -> JobInsertCall<'a, C, A> { self._customer_phone_number = Some(new_value.to_string()); self } @@ -2925,7 +2921,7 @@ impl<'a, C, NC, A> JobInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Customer name - pub fn customer_name(mut self, new_value: &str) -> JobInsertCall<'a, C, NC, A> { + pub fn customer_name(mut self, new_value: &str) -> JobInsertCall<'a, C, A> { self._customer_name = Some(new_value.to_string()); self } @@ -2934,7 +2930,7 @@ impl<'a, C, NC, A> JobInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Sets the value of custom fields. To set a custom field, pass the field id (from /team/teamId/custom_fields), a URL escaped '=' character, and the desired value as a parameter. For example, customField=12%3DAlice. Repeat the parameter for each custom field. Note that '=' cannot appear in the parameter value. Specifying an invalid, or inactive enum field will result in an error 500. - pub fn add_custom_field(mut self, new_value: &str) -> JobInsertCall<'a, C, NC, A> { + pub fn add_custom_field(mut self, new_value: &str) -> JobInsertCall<'a, C, A> { self._custom_field.push(new_value.to_string()); self } @@ -2942,7 +2938,7 @@ impl<'a, C, NC, A> JobInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Assignee email address, or empty string to unassign. - pub fn assignee(mut self, new_value: &str) -> JobInsertCall<'a, C, NC, A> { + pub fn assignee(mut self, new_value: &str) -> JobInsertCall<'a, C, A> { self._assignee = Some(new_value.to_string()); self } @@ -2953,7 +2949,7 @@ impl<'a, C, NC, A> JobInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2974,7 +2970,7 @@ impl<'a, C, NC, A> JobInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> JobInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> JobInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2991,7 +2987,7 @@ impl<'a, C, NC, A> JobInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> JobInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> JobInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3039,10 +3035,10 @@ impl<'a, C, NC, A> JobInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct ScheduleUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ScheduleUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Coordinate, + hub: &'a Coordinate, _request: Schedule, _team_id: String, _job_id: String, @@ -3055,9 +3051,9 @@ pub struct ScheduleUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ScheduleUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ScheduleUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ScheduleUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ScheduleUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3209,7 +3205,7 @@ impl<'a, C, NC, A> ScheduleUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Schedule) -> ScheduleUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Schedule) -> ScheduleUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3219,7 +3215,7 @@ impl<'a, C, NC, A> ScheduleUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Team ID - pub fn team_id(mut self, new_value: &str) -> ScheduleUpdateCall<'a, C, NC, A> { + pub fn team_id(mut self, new_value: &str) -> ScheduleUpdateCall<'a, C, A> { self._team_id = new_value.to_string(); self } @@ -3229,7 +3225,7 @@ impl<'a, C, NC, A> ScheduleUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Job number - pub fn job_id(mut self, new_value: &str) -> ScheduleUpdateCall<'a, C, NC, A> { + pub fn job_id(mut self, new_value: &str) -> ScheduleUpdateCall<'a, C, A> { self._job_id = new_value.to_string(); self } @@ -3237,7 +3233,7 @@ impl<'a, C, NC, A> ScheduleUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Scheduled start time in milliseconds since epoch. - pub fn start_time(mut self, new_value: &str) -> ScheduleUpdateCall<'a, C, NC, A> { + pub fn start_time(mut self, new_value: &str) -> ScheduleUpdateCall<'a, C, A> { self._start_time = Some(new_value.to_string()); self } @@ -3245,7 +3241,7 @@ impl<'a, C, NC, A> ScheduleUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Scheduled end time in milliseconds since epoch. - pub fn end_time(mut self, new_value: &str) -> ScheduleUpdateCall<'a, C, NC, A> { + pub fn end_time(mut self, new_value: &str) -> ScheduleUpdateCall<'a, C, A> { self._end_time = Some(new_value.to_string()); self } @@ -3253,7 +3249,7 @@ impl<'a, C, NC, A> ScheduleUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Job duration in milliseconds. - pub fn duration(mut self, new_value: &str) -> ScheduleUpdateCall<'a, C, NC, A> { + pub fn duration(mut self, new_value: &str) -> ScheduleUpdateCall<'a, C, A> { self._duration = Some(new_value.to_string()); self } @@ -3261,7 +3257,7 @@ impl<'a, C, NC, A> ScheduleUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Whether the job is scheduled for the whole day. Time of day in start/end times is ignored if this is true. - pub fn all_day(mut self, new_value: bool) -> ScheduleUpdateCall<'a, C, NC, A> { + pub fn all_day(mut self, new_value: bool) -> ScheduleUpdateCall<'a, C, A> { self._all_day = Some(new_value); self } @@ -3272,7 +3268,7 @@ impl<'a, C, NC, A> ScheduleUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScheduleUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScheduleUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3293,7 +3289,7 @@ impl<'a, C, NC, A> ScheduleUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ScheduleUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ScheduleUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3310,7 +3306,7 @@ impl<'a, C, NC, A> ScheduleUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ScheduleUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ScheduleUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3358,10 +3354,10 @@ impl<'a, C, NC, A> ScheduleUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct SchedulePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SchedulePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Coordinate, + hub: &'a Coordinate, _request: Schedule, _team_id: String, _job_id: String, @@ -3374,9 +3370,9 @@ pub struct SchedulePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SchedulePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SchedulePatchCall<'a, C, A> {} -impl<'a, C, NC, A> SchedulePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SchedulePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3528,7 +3524,7 @@ impl<'a, C, NC, A> SchedulePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Schedule) -> SchedulePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Schedule) -> SchedulePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3538,7 +3534,7 @@ impl<'a, C, NC, A> SchedulePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Team ID - pub fn team_id(mut self, new_value: &str) -> SchedulePatchCall<'a, C, NC, A> { + pub fn team_id(mut self, new_value: &str) -> SchedulePatchCall<'a, C, A> { self._team_id = new_value.to_string(); self } @@ -3548,7 +3544,7 @@ impl<'a, C, NC, A> SchedulePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Job number - pub fn job_id(mut self, new_value: &str) -> SchedulePatchCall<'a, C, NC, A> { + pub fn job_id(mut self, new_value: &str) -> SchedulePatchCall<'a, C, A> { self._job_id = new_value.to_string(); self } @@ -3556,7 +3552,7 @@ impl<'a, C, NC, A> SchedulePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Scheduled start time in milliseconds since epoch. - pub fn start_time(mut self, new_value: &str) -> SchedulePatchCall<'a, C, NC, A> { + pub fn start_time(mut self, new_value: &str) -> SchedulePatchCall<'a, C, A> { self._start_time = Some(new_value.to_string()); self } @@ -3564,7 +3560,7 @@ impl<'a, C, NC, A> SchedulePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Scheduled end time in milliseconds since epoch. - pub fn end_time(mut self, new_value: &str) -> SchedulePatchCall<'a, C, NC, A> { + pub fn end_time(mut self, new_value: &str) -> SchedulePatchCall<'a, C, A> { self._end_time = Some(new_value.to_string()); self } @@ -3572,7 +3568,7 @@ impl<'a, C, NC, A> SchedulePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Job duration in milliseconds. - pub fn duration(mut self, new_value: &str) -> SchedulePatchCall<'a, C, NC, A> { + pub fn duration(mut self, new_value: &str) -> SchedulePatchCall<'a, C, A> { self._duration = Some(new_value.to_string()); self } @@ -3580,7 +3576,7 @@ impl<'a, C, NC, A> SchedulePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Whether the job is scheduled for the whole day. Time of day in start/end times is ignored if this is true. - pub fn all_day(mut self, new_value: bool) -> SchedulePatchCall<'a, C, NC, A> { + pub fn all_day(mut self, new_value: bool) -> SchedulePatchCall<'a, C, A> { self._all_day = Some(new_value); self } @@ -3591,7 +3587,7 @@ impl<'a, C, NC, A> SchedulePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SchedulePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SchedulePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3612,7 +3608,7 @@ impl<'a, C, NC, A> SchedulePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SchedulePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SchedulePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3629,7 +3625,7 @@ impl<'a, C, NC, A> SchedulePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SchedulePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SchedulePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3667,10 +3663,10 @@ impl<'a, C, NC, A> SchedulePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct ScheduleGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ScheduleGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Coordinate, + hub: &'a Coordinate, _team_id: String, _job_id: String, _delegate: Option<&'a mut Delegate>, @@ -3678,9 +3674,9 @@ pub struct ScheduleGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ScheduleGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ScheduleGetCall<'a, C, A> {} -impl<'a, C, NC, A> ScheduleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ScheduleGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3813,7 +3809,7 @@ impl<'a, C, NC, A> ScheduleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Team ID - pub fn team_id(mut self, new_value: &str) -> ScheduleGetCall<'a, C, NC, A> { + pub fn team_id(mut self, new_value: &str) -> ScheduleGetCall<'a, C, A> { self._team_id = new_value.to_string(); self } @@ -3823,7 +3819,7 @@ impl<'a, C, NC, A> ScheduleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Job number - pub fn job_id(mut self, new_value: &str) -> ScheduleGetCall<'a, C, NC, A> { + pub fn job_id(mut self, new_value: &str) -> ScheduleGetCall<'a, C, A> { self._job_id = new_value.to_string(); self } @@ -3834,7 +3830,7 @@ impl<'a, C, NC, A> ScheduleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScheduleGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScheduleGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3855,7 +3851,7 @@ impl<'a, C, NC, A> ScheduleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ScheduleGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ScheduleGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3872,7 +3868,7 @@ impl<'a, C, NC, A> ScheduleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ScheduleGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ScheduleGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3910,19 +3906,19 @@ impl<'a, C, NC, A> ScheduleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct WorkerListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct WorkerListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Coordinate, + hub: &'a Coordinate, _team_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for WorkerListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for WorkerListCall<'a, C, A> {} -impl<'a, C, NC, A> WorkerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> WorkerListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4054,7 +4050,7 @@ impl<'a, C, NC, A> WorkerListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Team ID - pub fn team_id(mut self, new_value: &str) -> WorkerListCall<'a, C, NC, A> { + pub fn team_id(mut self, new_value: &str) -> WorkerListCall<'a, C, A> { self._team_id = new_value.to_string(); self } @@ -4065,7 +4061,7 @@ impl<'a, C, NC, A> WorkerListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> WorkerListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> WorkerListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4086,7 +4082,7 @@ impl<'a, C, NC, A> WorkerListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> WorkerListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> WorkerListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4103,7 +4099,7 @@ impl<'a, C, NC, A> WorkerListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> WorkerListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> WorkerListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4143,10 +4139,10 @@ impl<'a, C, NC, A> WorkerListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct LocationListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LocationListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Coordinate, + hub: &'a Coordinate, _team_id: String, _worker_email: String, _start_timestamp_ms: String, @@ -4157,9 +4153,9 @@ pub struct LocationListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LocationListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LocationListCall<'a, C, A> {} -impl<'a, C, NC, A> LocationListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LocationListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4299,7 +4295,7 @@ impl<'a, C, NC, A> LocationListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Team ID - pub fn team_id(mut self, new_value: &str) -> LocationListCall<'a, C, NC, A> { + pub fn team_id(mut self, new_value: &str) -> LocationListCall<'a, C, A> { self._team_id = new_value.to_string(); self } @@ -4309,7 +4305,7 @@ impl<'a, C, NC, A> LocationListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Worker email address. - pub fn worker_email(mut self, new_value: &str) -> LocationListCall<'a, C, NC, A> { + pub fn worker_email(mut self, new_value: &str) -> LocationListCall<'a, C, A> { self._worker_email = new_value.to_string(); self } @@ -4319,7 +4315,7 @@ impl<'a, C, NC, A> LocationListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Start timestamp in milliseconds since the epoch. - pub fn start_timestamp_ms(mut self, new_value: &str) -> LocationListCall<'a, C, NC, A> { + pub fn start_timestamp_ms(mut self, new_value: &str) -> LocationListCall<'a, C, A> { self._start_timestamp_ms = new_value.to_string(); self } @@ -4327,7 +4323,7 @@ impl<'a, C, NC, A> LocationListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Continuation token - pub fn page_token(mut self, new_value: &str) -> LocationListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> LocationListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -4335,7 +4331,7 @@ impl<'a, C, NC, A> LocationListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Maximum number of results to return in one page. - pub fn max_results(mut self, new_value: u32) -> LocationListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> LocationListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -4346,7 +4342,7 @@ impl<'a, C, NC, A> LocationListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LocationListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LocationListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4367,7 +4363,7 @@ impl<'a, C, NC, A> LocationListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LocationListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LocationListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4384,7 +4380,7 @@ impl<'a, C, NC, A> LocationListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LocationListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LocationListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4425,10 +4421,10 @@ impl<'a, C, NC, A> LocationListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct TeamListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TeamListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Coordinate, + hub: &'a Coordinate, _worker: Option, _dispatcher: Option, _admin: Option, @@ -4437,9 +4433,9 @@ pub struct TeamListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TeamListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TeamListCall<'a, C, A> {} -impl<'a, C, NC, A> TeamListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TeamListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4553,7 +4549,7 @@ impl<'a, C, NC, A> TeamListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Whether to include teams for which the user has the Worker role. - pub fn worker(mut self, new_value: bool) -> TeamListCall<'a, C, NC, A> { + pub fn worker(mut self, new_value: bool) -> TeamListCall<'a, C, A> { self._worker = Some(new_value); self } @@ -4561,7 +4557,7 @@ impl<'a, C, NC, A> TeamListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Whether to include teams for which the user has the Dispatcher role. - pub fn dispatcher(mut self, new_value: bool) -> TeamListCall<'a, C, NC, A> { + pub fn dispatcher(mut self, new_value: bool) -> TeamListCall<'a, C, A> { self._dispatcher = Some(new_value); self } @@ -4569,7 +4565,7 @@ impl<'a, C, NC, A> TeamListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Whether to include teams for which the user has the Admin role. - pub fn admin(mut self, new_value: bool) -> TeamListCall<'a, C, NC, A> { + pub fn admin(mut self, new_value: bool) -> TeamListCall<'a, C, A> { self._admin = Some(new_value); self } @@ -4580,7 +4576,7 @@ impl<'a, C, NC, A> TeamListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TeamListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TeamListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4601,7 +4597,7 @@ impl<'a, C, NC, A> TeamListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TeamListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TeamListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4618,7 +4614,7 @@ impl<'a, C, NC, A> TeamListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TeamListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TeamListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4656,19 +4652,19 @@ impl<'a, C, NC, A> TeamListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct CustomFieldDefListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CustomFieldDefListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Coordinate, + hub: &'a Coordinate, _team_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CustomFieldDefListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CustomFieldDefListCall<'a, C, A> {} -impl<'a, C, NC, A> CustomFieldDefListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CustomFieldDefListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4800,7 +4796,7 @@ impl<'a, C, NC, A> CustomFieldDefListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Team ID - pub fn team_id(mut self, new_value: &str) -> CustomFieldDefListCall<'a, C, NC, A> { + pub fn team_id(mut self, new_value: &str) -> CustomFieldDefListCall<'a, C, A> { self._team_id = new_value.to_string(); self } @@ -4811,7 +4807,7 @@ impl<'a, C, NC, A> CustomFieldDefListCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomFieldDefListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomFieldDefListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4832,7 +4828,7 @@ impl<'a, C, NC, A> CustomFieldDefListCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CustomFieldDefListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CustomFieldDefListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4849,7 +4845,7 @@ impl<'a, C, NC, A> CustomFieldDefListCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CustomFieldDefListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CustomFieldDefListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/customsearch1/Cargo.toml b/gen/customsearch1/Cargo.toml index 1a1e93443fd..4acbbf24805 100644 --- a/gen/customsearch1/Cargo.toml +++ b/gen/customsearch1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-customsearch1" -version = "0.1.4+20131205" +version = "0.1.5+20131205" authors = ["Sebastian Thiel "] description = "A complete library to interact with customsearch (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/customsearch1" homepage = "https://developers.google.com/custom-search/v1/using_rest" -documentation = "http://byron.github.io/google-apis-rs/google-customsearch1" +documentation = "http://byron.github.io/google-apis-rs/google_customsearch1" license = "MIT" keywords = ["customsearch", "google", "protocol", "web", "api"] diff --git a/gen/customsearch1/README.md b/gen/customsearch1/README.md index d9409571c25..1c4a408271e 100644 --- a/gen/customsearch1/README.md +++ b/gen/customsearch1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-customsearch1` library allows access to all features of the *Google customsearch* service. -This documentation was generated from *customsearch* crate version *0.1.4+20131205*, where *20131205* is the exact revision of the *customsearch:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *customsearch* crate version *0.1.5+20131205*, where *20131205* is the exact revision of the *customsearch:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *customsearch* *v1* API can be found at the [official documentation site](https://developers.google.com/custom-search/v1/using_rest). diff --git a/gen/customsearch1/src/cmn.rs b/gen/customsearch1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/customsearch1/src/cmn.rs +++ b/gen/customsearch1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/customsearch1/src/lib.rs b/gen/customsearch1/src/lib.rs index 99a9613f563..993843e7ee6 100644 --- a/gen/customsearch1/src/lib.rs +++ b/gen/customsearch1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *customsearch* crate version *0.1.4+20131205*, where *20131205* is the exact revision of the *customsearch:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *customsearch* crate version *0.1.5+20131205*, where *20131205* is the exact revision of the *customsearch:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *customsearch* *v1* API can be found at the //! [official documentation site](https://developers.google.com/custom-search/v1/using_rest). @@ -219,7 +219,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -319,34 +318,31 @@ pub use cmn::{MultiPartReader, ToParts, MethodInfo, Result, Error, CallBuilder, /// } /// # } /// ``` -pub struct Customsearch { +pub struct Customsearch { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Customsearch {} +impl<'a, C, A> Hub for Customsearch {} -impl<'a, C, NC, A> Customsearch - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Customsearch + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Customsearch { + pub fn new(client: C, authenticator: A) -> Customsearch { Customsearch { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn cse(&'a self) -> CseMethods<'a, C, NC, A> { + pub fn cse(&'a self) -> CseMethods<'a, C, A> { CseMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -790,15 +786,15 @@ impl Part for ResultLabels {} /// let rb = hub.cse(); /// # } /// ``` -pub struct CseMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CseMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Customsearch, + hub: &'a Customsearch, } -impl<'a, C, NC, A> MethodsBuilder for CseMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CseMethods<'a, C, A> {} -impl<'a, C, NC, A> CseMethods<'a, C, NC, A> { +impl<'a, C, A> CseMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -807,7 +803,7 @@ impl<'a, C, NC, A> CseMethods<'a, C, NC, A> { /// # Arguments /// /// * `q` - Query - pub fn list(&self, q: &str) -> CseListCall<'a, C, NC, A> { + pub fn list(&self, q: &str) -> CseListCall<'a, C, A> { CseListCall { hub: self.hub, _q: q.to_string(), @@ -917,10 +913,10 @@ impl<'a, C, NC, A> CseMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct CseListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CseListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Customsearch, + hub: &'a Customsearch, _q: String, _start: Option, _sort: Option, @@ -957,9 +953,9 @@ pub struct CseListCall<'a, C, NC, A> _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for CseListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CseListCall<'a, C, A> {} -impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CseListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1158,7 +1154,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// Query - pub fn q(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn q(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._q = new_value.to_string(); self } @@ -1166,7 +1162,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// The index of the first result to return - pub fn start(mut self, new_value: u32) -> CseListCall<'a, C, NC, A> { + pub fn start(mut self, new_value: u32) -> CseListCall<'a, C, A> { self._start = Some(new_value); self } @@ -1174,7 +1170,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// The sort expression to apply to the results - pub fn sort(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn sort(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._sort = Some(new_value.to_string()); self } @@ -1182,7 +1178,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Controls whether to include or exclude results from the site named in the as_sitesearch parameter - pub fn site_search_filter(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn site_search_filter(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._site_search_filter = Some(new_value.to_string()); self } @@ -1190,7 +1186,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Specifies all search results should be pages from a given site - pub fn site_search(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn site_search(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._site_search = Some(new_value.to_string()); self } @@ -1198,7 +1194,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Specifies the search type: image. - pub fn search_type(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn search_type(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._search_type = Some(new_value.to_string()); self } @@ -1206,7 +1202,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Search safety level - pub fn safe(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn safe(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._safe = Some(new_value.to_string()); self } @@ -1214,7 +1210,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Filters based on licensing. Supported values include: cc_publicdomain, cc_attribute, cc_sharealike, cc_noncommercial, cc_nonderived and combinations of these. - pub fn rights(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn rights(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._rights = Some(new_value.to_string()); self } @@ -1222,7 +1218,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Specifies that all search results should be pages that are related to the specified URL - pub fn related_site(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn related_site(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._related_site = Some(new_value.to_string()); self } @@ -1230,7 +1226,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Provides additional search terms to check for in a document, where each document in the search results must contain at least one of the additional search terms - pub fn or_terms(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn or_terms(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._or_terms = Some(new_value.to_string()); self } @@ -1238,7 +1234,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Number of search results to return - pub fn num(mut self, new_value: u32) -> CseListCall<'a, C, NC, A> { + pub fn num(mut self, new_value: u32) -> CseListCall<'a, C, A> { self._num = Some(new_value); self } @@ -1246,7 +1242,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// The language restriction for the search results - pub fn lr(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn lr(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._lr = Some(new_value.to_string()); self } @@ -1254,7 +1250,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Creates a range in form as_nlo value..as_nhi value and attempts to append it to query - pub fn low_range(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn low_range(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._low_range = Some(new_value.to_string()); self } @@ -1262,7 +1258,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Specifies that all search results should contain a link to a particular URL - pub fn link_site(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn link_site(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._link_site = Some(new_value.to_string()); self } @@ -1270,7 +1266,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Returns images of a type, which can be one of: clipart, face, lineart, news, and photo. - pub fn img_type(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn img_type(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._img_type = Some(new_value.to_string()); self } @@ -1278,7 +1274,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Returns images of a specified size, where size can be one of: icon, small, medium, large, xlarge, xxlarge, and huge. - pub fn img_size(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn img_size(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._img_size = Some(new_value.to_string()); self } @@ -1286,7 +1282,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Returns images of a specific dominant color: yellow, green, teal, blue, purple, pink, white, gray, black and brown. - pub fn img_dominant_color(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn img_dominant_color(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._img_dominant_color = Some(new_value.to_string()); self } @@ -1294,7 +1290,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Returns black and white, grayscale, or color images: mono, gray, and color. - pub fn img_color_type(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn img_color_type(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._img_color_type = Some(new_value.to_string()); self } @@ -1302,7 +1298,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Appends the extra query terms to the query. - pub fn hq(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn hq(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._hq = Some(new_value.to_string()); self } @@ -1310,7 +1306,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Sets the user interface language. - pub fn hl(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn hl(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._hl = Some(new_value.to_string()); self } @@ -1318,7 +1314,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Creates a range in form as_nlo value..as_nhi value and attempts to append it to query - pub fn high_range(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn high_range(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._high_range = Some(new_value.to_string()); self } @@ -1326,7 +1322,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// The local Google domain to use to perform the search. - pub fn googlehost(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn googlehost(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._googlehost = Some(new_value.to_string()); self } @@ -1334,7 +1330,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Geolocation of end user. - pub fn gl(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn gl(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._gl = Some(new_value.to_string()); self } @@ -1342,7 +1338,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Controls turning on or off the duplicate content filter. - pub fn filter(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -1350,7 +1346,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Returns images of a specified type. Some of the allowed values are: bmp, gif, png, jpg, svg, pdf, ... - pub fn file_type(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn file_type(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._file_type = Some(new_value.to_string()); self } @@ -1358,7 +1354,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Identifies a word or phrase that should not appear in any documents in the search results - pub fn exclude_terms(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn exclude_terms(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._exclude_terms = Some(new_value.to_string()); self } @@ -1366,7 +1362,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Identifies a phrase that all documents in the search results must contain - pub fn exact_terms(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn exact_terms(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._exact_terms = Some(new_value.to_string()); self } @@ -1374,7 +1370,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Specifies all search results are from a time period - pub fn date_restrict(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn date_restrict(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._date_restrict = Some(new_value.to_string()); self } @@ -1382,7 +1378,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// The custom search engine ID to scope this search query - pub fn cx(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn cx(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._cx = Some(new_value.to_string()); self } @@ -1390,7 +1386,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// The URL of a linked custom search engine - pub fn cref(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn cref(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._cref = Some(new_value.to_string()); self } @@ -1398,7 +1394,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Country restrict(s). - pub fn cr(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn cr(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._cr = Some(new_value.to_string()); self } @@ -1406,7 +1402,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Turns off the translation between zh-CN and zh-TW. - pub fn c2coff(mut self, new_value: &str) -> CseListCall<'a, C, NC, A> { + pub fn c2coff(mut self, new_value: &str) -> CseListCall<'a, C, A> { self._c2coff = Some(new_value.to_string()); self } @@ -1417,7 +1413,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CseListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CseListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1438,7 +1434,7 @@ impl<'a, C, NC, A> CseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CseListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CseListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self diff --git a/gen/dataflow1_b4/Cargo.toml b/gen/dataflow1_b4/Cargo.toml index 2881df5ed22..199c9cdcefb 100644 --- a/gen/dataflow1_b4/Cargo.toml +++ b/gen/dataflow1_b4/Cargo.toml @@ -4,11 +4,11 @@ [package] name = "google-dataflow1_b4" -version = "0.1.4+20150401" +version = "0.1.5+20150401" authors = ["Sebastian Thiel "] description = "A complete library to interact with dataflow (protocol v1b4)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/dataflow1_b4" -documentation = "http://byron.github.io/google-apis-rs/google-dataflow1_b4" +documentation = "http://byron.github.io/google-apis-rs/google_dataflow1_b4" license = "MIT" keywords = ["dataflow", "google", "protocol", "web", "api"] diff --git a/gen/dataflow1_b4/README.md b/gen/dataflow1_b4/README.md index ec2cbca0b4c..f474dcdee23 100644 --- a/gen/dataflow1_b4/README.md +++ b/gen/dataflow1_b4/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-dataflow1_b4` library allows access to all features of the *Google dataflow* service. -This documentation was generated from *dataflow* crate version *0.1.4+20150401*, where *20150401* is the exact revision of the *dataflow:v1b4* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *dataflow* crate version *0.1.5+20150401*, where *20150401* is the exact revision of the *dataflow:v1b4* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. # Features It seems there is nothing you can do here ... . diff --git a/gen/dataflow1_b4/src/cmn.rs b/gen/dataflow1_b4/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/dataflow1_b4/src/cmn.rs +++ b/gen/dataflow1_b4/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/dataflow1_b4/src/lib.rs b/gen/dataflow1_b4/src/lib.rs index 1bdc021fac0..3c128163c93 100644 --- a/gen/dataflow1_b4/src/lib.rs +++ b/gen/dataflow1_b4/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *dataflow* crate version *0.1.4+20150401*, where *20150401* is the exact revision of the *dataflow:v1b4* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *dataflow* crate version *0.1.5+20150401*, where *20150401* is the exact revision of the *dataflow:v1b4* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/master/gen/dataflow1_b4). //! # Features //! @@ -160,7 +160,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -211,31 +210,28 @@ pub use cmn::{MultiPartReader, ToParts, MethodInfo, Result, Error, CallBuilder, /// # } /// ``` /// -pub struct Dataflow { +pub struct Dataflow { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Dataflow {} +impl<'a, C, A> Hub for Dataflow {} -impl<'a, C, NC, A> Dataflow - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Dataflow + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Dataflow { + pub fn new(client: C, authenticator: A) -> Dataflow { Dataflow { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { diff --git a/gen/datastore1_beta2/Cargo.toml b/gen/datastore1_beta2/Cargo.toml index 363550e1a59..ac216d2c182 100644 --- a/gen/datastore1_beta2/Cargo.toml +++ b/gen/datastore1_beta2/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-datastore1_beta2" -version = "0.1.4+20140916" +version = "0.1.5+20140916" authors = ["Sebastian Thiel "] description = "A complete library to interact with datastore (protocol v1beta2)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/datastore1_beta2" homepage = "https://developers.google.com/datastore/" -documentation = "http://byron.github.io/google-apis-rs/google-datastore1_beta2" +documentation = "http://byron.github.io/google-apis-rs/google_datastore1_beta2" license = "MIT" keywords = ["datastore", "google", "protocol", "web", "api"] diff --git a/gen/datastore1_beta2/README.md b/gen/datastore1_beta2/README.md index f55d02b1bf7..35d10760fc2 100644 --- a/gen/datastore1_beta2/README.md +++ b/gen/datastore1_beta2/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-datastore1_beta2` library allows access to all features of the *Google datastore* service. -This documentation was generated from *datastore* crate version *0.1.4+20140916*, where *20140916* is the exact revision of the *datastore:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *datastore* crate version *0.1.5+20140916*, where *20140916* is the exact revision of the *datastore:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *datastore* *v1_beta2* API can be found at the [official documentation site](https://developers.google.com/datastore/). diff --git a/gen/datastore1_beta2/src/cmn.rs b/gen/datastore1_beta2/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/datastore1_beta2/src/cmn.rs +++ b/gen/datastore1_beta2/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/datastore1_beta2/src/lib.rs b/gen/datastore1_beta2/src/lib.rs index 8c9057c88a8..529879f8001 100644 --- a/gen/datastore1_beta2/src/lib.rs +++ b/gen/datastore1_beta2/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *datastore* crate version *0.1.4+20140916*, where *20140916* is the exact revision of the *datastore:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *datastore* crate version *0.1.5+20140916*, where *20140916* is the exact revision of the *datastore:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *datastore* *v1_beta2* API can be found at the //! [official documentation site](https://developers.google.com/datastore/). @@ -194,7 +194,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -299,34 +298,31 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Datastore { +pub struct Datastore { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Datastore {} +impl<'a, C, A> Hub for Datastore {} -impl<'a, C, NC, A> Datastore - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Datastore + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Datastore { + pub fn new(client: C, authenticator: A) -> Datastore { Datastore { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn datasets(&'a self) -> DatasetMethods<'a, C, NC, A> { + pub fn datasets(&'a self) -> DatasetMethods<'a, C, A> { DatasetMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -1075,15 +1071,15 @@ impl Part for Query {} /// let rb = hub.datasets(); /// # } /// ``` -pub struct DatasetMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatasetMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Datastore, + hub: &'a Datastore, } -impl<'a, C, NC, A> MethodsBuilder for DatasetMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for DatasetMethods<'a, C, A> {} -impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { +impl<'a, C, A> DatasetMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1093,7 +1089,7 @@ impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `datasetId` - Identifies the dataset. - pub fn commit(&self, request: &CommitRequest, dataset_id: &str) -> DatasetCommitCall<'a, C, NC, A> { + pub fn commit(&self, request: &CommitRequest, dataset_id: &str) -> DatasetCommitCall<'a, C, A> { DatasetCommitCall { hub: self.hub, _request: request.clone(), @@ -1112,7 +1108,7 @@ impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `datasetId` - Identifies the dataset. - pub fn allocate_ids(&self, request: &AllocateIdsRequest, dataset_id: &str) -> DatasetAllocateIdCall<'a, C, NC, A> { + pub fn allocate_ids(&self, request: &AllocateIdsRequest, dataset_id: &str) -> DatasetAllocateIdCall<'a, C, A> { DatasetAllocateIdCall { hub: self.hub, _request: request.clone(), @@ -1131,7 +1127,7 @@ impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `datasetId` - Identifies the dataset. - pub fn rollback(&self, request: &RollbackRequest, dataset_id: &str) -> DatasetRollbackCall<'a, C, NC, A> { + pub fn rollback(&self, request: &RollbackRequest, dataset_id: &str) -> DatasetRollbackCall<'a, C, A> { DatasetRollbackCall { hub: self.hub, _request: request.clone(), @@ -1150,7 +1146,7 @@ impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `datasetId` - Identifies the dataset. - pub fn lookup(&self, request: &LookupRequest, dataset_id: &str) -> DatasetLookupCall<'a, C, NC, A> { + pub fn lookup(&self, request: &LookupRequest, dataset_id: &str) -> DatasetLookupCall<'a, C, A> { DatasetLookupCall { hub: self.hub, _request: request.clone(), @@ -1169,7 +1165,7 @@ impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `datasetId` - Identifies the dataset. - pub fn run_query(&self, request: &RunQueryRequest, dataset_id: &str) -> DatasetRunQueryCall<'a, C, NC, A> { + pub fn run_query(&self, request: &RunQueryRequest, dataset_id: &str) -> DatasetRunQueryCall<'a, C, A> { DatasetRunQueryCall { hub: self.hub, _request: request.clone(), @@ -1188,7 +1184,7 @@ impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `datasetId` - Identifies the dataset. - pub fn begin_transaction(&self, request: &BeginTransactionRequest, dataset_id: &str) -> DatasetBeginTransactionCall<'a, C, NC, A> { + pub fn begin_transaction(&self, request: &BeginTransactionRequest, dataset_id: &str) -> DatasetBeginTransactionCall<'a, C, A> { DatasetBeginTransactionCall { hub: self.hub, _request: request.clone(), @@ -1244,10 +1240,10 @@ impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct DatasetCommitCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatasetCommitCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Datastore, + hub: &'a Datastore, _request: CommitRequest, _dataset_id: String, _delegate: Option<&'a mut Delegate>, @@ -1255,9 +1251,9 @@ pub struct DatasetCommitCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatasetCommitCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatasetCommitCall<'a, C, A> {} -impl<'a, C, NC, A> DatasetCommitCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatasetCommitCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1396,7 +1392,7 @@ impl<'a, C, NC, A> DatasetCommitCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CommitRequest) -> DatasetCommitCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CommitRequest) -> DatasetCommitCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1406,7 +1402,7 @@ impl<'a, C, NC, A> DatasetCommitCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Identifies the dataset. - pub fn dataset_id(mut self, new_value: &str) -> DatasetCommitCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> DatasetCommitCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -1417,7 +1413,7 @@ impl<'a, C, NC, A> DatasetCommitCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetCommitCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetCommitCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1438,7 +1434,7 @@ impl<'a, C, NC, A> DatasetCommitCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatasetCommitCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatasetCommitCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1455,7 +1451,7 @@ impl<'a, C, NC, A> DatasetCommitCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatasetCommitCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatasetCommitCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1499,10 +1495,10 @@ impl<'a, C, NC, A> DatasetCommitCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct DatasetAllocateIdCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatasetAllocateIdCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Datastore, + hub: &'a Datastore, _request: AllocateIdsRequest, _dataset_id: String, _delegate: Option<&'a mut Delegate>, @@ -1510,9 +1506,9 @@ pub struct DatasetAllocateIdCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatasetAllocateIdCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatasetAllocateIdCall<'a, C, A> {} -impl<'a, C, NC, A> DatasetAllocateIdCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatasetAllocateIdCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1651,7 +1647,7 @@ impl<'a, C, NC, A> DatasetAllocateIdCall<'a, C, NC, A> where NC: hyper::net::Net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AllocateIdsRequest) -> DatasetAllocateIdCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AllocateIdsRequest) -> DatasetAllocateIdCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1661,7 +1657,7 @@ impl<'a, C, NC, A> DatasetAllocateIdCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Identifies the dataset. - pub fn dataset_id(mut self, new_value: &str) -> DatasetAllocateIdCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> DatasetAllocateIdCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -1672,7 +1668,7 @@ impl<'a, C, NC, A> DatasetAllocateIdCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetAllocateIdCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetAllocateIdCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1693,7 +1689,7 @@ impl<'a, C, NC, A> DatasetAllocateIdCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatasetAllocateIdCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatasetAllocateIdCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1710,7 +1706,7 @@ impl<'a, C, NC, A> DatasetAllocateIdCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatasetAllocateIdCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatasetAllocateIdCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1754,10 +1750,10 @@ impl<'a, C, NC, A> DatasetAllocateIdCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct DatasetRollbackCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatasetRollbackCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Datastore, + hub: &'a Datastore, _request: RollbackRequest, _dataset_id: String, _delegate: Option<&'a mut Delegate>, @@ -1765,9 +1761,9 @@ pub struct DatasetRollbackCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatasetRollbackCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatasetRollbackCall<'a, C, A> {} -impl<'a, C, NC, A> DatasetRollbackCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatasetRollbackCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1906,7 +1902,7 @@ impl<'a, C, NC, A> DatasetRollbackCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &RollbackRequest) -> DatasetRollbackCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &RollbackRequest) -> DatasetRollbackCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1916,7 +1912,7 @@ impl<'a, C, NC, A> DatasetRollbackCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Identifies the dataset. - pub fn dataset_id(mut self, new_value: &str) -> DatasetRollbackCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> DatasetRollbackCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -1927,7 +1923,7 @@ impl<'a, C, NC, A> DatasetRollbackCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetRollbackCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetRollbackCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1948,7 +1944,7 @@ impl<'a, C, NC, A> DatasetRollbackCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatasetRollbackCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatasetRollbackCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1965,7 +1961,7 @@ impl<'a, C, NC, A> DatasetRollbackCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatasetRollbackCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatasetRollbackCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2009,10 +2005,10 @@ impl<'a, C, NC, A> DatasetRollbackCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct DatasetLookupCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatasetLookupCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Datastore, + hub: &'a Datastore, _request: LookupRequest, _dataset_id: String, _delegate: Option<&'a mut Delegate>, @@ -2020,9 +2016,9 @@ pub struct DatasetLookupCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatasetLookupCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatasetLookupCall<'a, C, A> {} -impl<'a, C, NC, A> DatasetLookupCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatasetLookupCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2161,7 +2157,7 @@ impl<'a, C, NC, A> DatasetLookupCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &LookupRequest) -> DatasetLookupCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &LookupRequest) -> DatasetLookupCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2171,7 +2167,7 @@ impl<'a, C, NC, A> DatasetLookupCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Identifies the dataset. - pub fn dataset_id(mut self, new_value: &str) -> DatasetLookupCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> DatasetLookupCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -2182,7 +2178,7 @@ impl<'a, C, NC, A> DatasetLookupCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetLookupCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetLookupCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2203,7 +2199,7 @@ impl<'a, C, NC, A> DatasetLookupCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatasetLookupCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatasetLookupCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2220,7 +2216,7 @@ impl<'a, C, NC, A> DatasetLookupCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatasetLookupCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatasetLookupCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2264,10 +2260,10 @@ impl<'a, C, NC, A> DatasetLookupCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct DatasetRunQueryCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatasetRunQueryCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Datastore, + hub: &'a Datastore, _request: RunQueryRequest, _dataset_id: String, _delegate: Option<&'a mut Delegate>, @@ -2275,9 +2271,9 @@ pub struct DatasetRunQueryCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatasetRunQueryCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatasetRunQueryCall<'a, C, A> {} -impl<'a, C, NC, A> DatasetRunQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatasetRunQueryCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2416,7 +2412,7 @@ impl<'a, C, NC, A> DatasetRunQueryCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &RunQueryRequest) -> DatasetRunQueryCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &RunQueryRequest) -> DatasetRunQueryCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2426,7 +2422,7 @@ impl<'a, C, NC, A> DatasetRunQueryCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Identifies the dataset. - pub fn dataset_id(mut self, new_value: &str) -> DatasetRunQueryCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> DatasetRunQueryCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -2437,7 +2433,7 @@ impl<'a, C, NC, A> DatasetRunQueryCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetRunQueryCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetRunQueryCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2458,7 +2454,7 @@ impl<'a, C, NC, A> DatasetRunQueryCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatasetRunQueryCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatasetRunQueryCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2475,7 +2471,7 @@ impl<'a, C, NC, A> DatasetRunQueryCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatasetRunQueryCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatasetRunQueryCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2519,10 +2515,10 @@ impl<'a, C, NC, A> DatasetRunQueryCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct DatasetBeginTransactionCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatasetBeginTransactionCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Datastore, + hub: &'a Datastore, _request: BeginTransactionRequest, _dataset_id: String, _delegate: Option<&'a mut Delegate>, @@ -2530,9 +2526,9 @@ pub struct DatasetBeginTransactionCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatasetBeginTransactionCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatasetBeginTransactionCall<'a, C, A> {} -impl<'a, C, NC, A> DatasetBeginTransactionCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatasetBeginTransactionCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2671,7 +2667,7 @@ impl<'a, C, NC, A> DatasetBeginTransactionCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &BeginTransactionRequest) -> DatasetBeginTransactionCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &BeginTransactionRequest) -> DatasetBeginTransactionCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2681,7 +2677,7 @@ impl<'a, C, NC, A> DatasetBeginTransactionCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Identifies the dataset. - pub fn dataset_id(mut self, new_value: &str) -> DatasetBeginTransactionCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> DatasetBeginTransactionCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -2692,7 +2688,7 @@ impl<'a, C, NC, A> DatasetBeginTransactionCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetBeginTransactionCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetBeginTransactionCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2713,7 +2709,7 @@ impl<'a, C, NC, A> DatasetBeginTransactionCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatasetBeginTransactionCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatasetBeginTransactionCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2730,7 +2726,7 @@ impl<'a, C, NC, A> DatasetBeginTransactionCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatasetBeginTransactionCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatasetBeginTransactionCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/deploymentmanager2_beta1/Cargo.toml b/gen/deploymentmanager2_beta1/Cargo.toml index c4761a96c30..283f1ecc73b 100644 --- a/gen/deploymentmanager2_beta1/Cargo.toml +++ b/gen/deploymentmanager2_beta1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-deploymentmanager2_beta1" -version = "0.1.4+20150303" +version = "0.1.5+20150303" authors = ["Sebastian Thiel "] description = "A complete library to interact with deploymentmanager (protocol v2beta1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/deploymentmanager2_beta1" homepage = "https://developers.google.com/deployment-manager/" -documentation = "http://byron.github.io/google-apis-rs/google-deploymentmanager2_beta1" +documentation = "http://byron.github.io/google-apis-rs/google_deploymentmanager2_beta1" license = "MIT" keywords = ["deploymentmanager", "google", "protocol", "web", "api"] diff --git a/gen/deploymentmanager2_beta1/README.md b/gen/deploymentmanager2_beta1/README.md index 95105699a35..dde8803da3f 100644 --- a/gen/deploymentmanager2_beta1/README.md +++ b/gen/deploymentmanager2_beta1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-deploymentmanager2_beta1` library allows access to all features of the *Google deploymentmanager* service. -This documentation was generated from *deploymentmanager* crate version *0.1.4+20150303*, where *20150303* is the exact revision of the *deploymentmanager:v2beta1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *deploymentmanager* crate version *0.1.5+20150303*, where *20150303* is the exact revision of the *deploymentmanager:v2beta1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *deploymentmanager* *v2_beta1* API can be found at the [official documentation site](https://developers.google.com/deployment-manager/). diff --git a/gen/deploymentmanager2_beta1/src/cmn.rs b/gen/deploymentmanager2_beta1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/deploymentmanager2_beta1/src/cmn.rs +++ b/gen/deploymentmanager2_beta1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/deploymentmanager2_beta1/src/lib.rs b/gen/deploymentmanager2_beta1/src/lib.rs index 3ef2111fb0c..9328b7e6f40 100644 --- a/gen/deploymentmanager2_beta1/src/lib.rs +++ b/gen/deploymentmanager2_beta1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *deploymentmanager* crate version *0.1.4+20150303*, where *20150303* is the exact revision of the *deploymentmanager:v2beta1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *deploymentmanager* crate version *0.1.5+20150303*, where *20150303* is the exact revision of the *deploymentmanager:v2beta1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *deploymentmanager* *v2_beta1* API can be found at the //! [official documentation site](https://developers.google.com/deployment-manager/). @@ -201,7 +201,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -302,46 +301,43 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Deploymentmanager { +pub struct Deploymentmanager { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Deploymentmanager {} +impl<'a, C, A> Hub for Deploymentmanager {} -impl<'a, C, NC, A> Deploymentmanager - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Deploymentmanager + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Deploymentmanager { + pub fn new(client: C, authenticator: A) -> Deploymentmanager { Deploymentmanager { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn deployments(&'a self) -> DeploymentMethods<'a, C, NC, A> { + pub fn deployments(&'a self) -> DeploymentMethods<'a, C, A> { DeploymentMethods { hub: &self } } - pub fn manifests(&'a self) -> ManifestMethods<'a, C, NC, A> { + pub fn manifests(&'a self) -> ManifestMethods<'a, C, A> { ManifestMethods { hub: &self } } - pub fn operations(&'a self) -> OperationMethods<'a, C, NC, A> { + pub fn operations(&'a self) -> OperationMethods<'a, C, A> { OperationMethods { hub: &self } } - pub fn resources(&'a self) -> ResourceMethods<'a, C, NC, A> { + pub fn resources(&'a self) -> ResourceMethods<'a, C, A> { ResourceMethods { hub: &self } } - pub fn types(&'a self) -> TypeMethods<'a, C, NC, A> { + pub fn types(&'a self) -> TypeMethods<'a, C, A> { TypeMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -738,15 +734,15 @@ impl ResponseResult for ManifestsListResponse {} /// let rb = hub.operations(); /// # } /// ``` -pub struct OperationMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct OperationMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Deploymentmanager, + hub: &'a Deploymentmanager, } -impl<'a, C, NC, A> MethodsBuilder for OperationMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for OperationMethods<'a, C, A> {} -impl<'a, C, NC, A> OperationMethods<'a, C, NC, A> { +impl<'a, C, A> OperationMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -756,7 +752,7 @@ impl<'a, C, NC, A> OperationMethods<'a, C, NC, A> { /// /// * `project` - ! The project ID for this request. /// * `operation` - ! The name of the operation for this request. - pub fn get(&self, project: &str, operation: &str) -> OperationGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, operation: &str) -> OperationGetCall<'a, C, A> { OperationGetCall { hub: self.hub, _project: project.to_string(), @@ -774,7 +770,7 @@ impl<'a, C, NC, A> OperationMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - ! The project ID for this request. - pub fn list(&self, project: &str) -> OperationListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> OperationListCall<'a, C, A> { OperationListCall { hub: self.hub, _project: project.to_string(), @@ -817,15 +813,15 @@ impl<'a, C, NC, A> OperationMethods<'a, C, NC, A> { /// let rb = hub.deployments(); /// # } /// ``` -pub struct DeploymentMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DeploymentMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Deploymentmanager, + hub: &'a Deploymentmanager, } -impl<'a, C, NC, A> MethodsBuilder for DeploymentMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for DeploymentMethods<'a, C, A> {} -impl<'a, C, NC, A> DeploymentMethods<'a, C, NC, A> { +impl<'a, C, A> DeploymentMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -835,7 +831,7 @@ impl<'a, C, NC, A> DeploymentMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `project` - ! The project ID for this request. - pub fn insert(&self, request: &Deployment, project: &str) -> DeploymentInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Deployment, project: &str) -> DeploymentInsertCall<'a, C, A> { DeploymentInsertCall { hub: self.hub, _request: request.clone(), @@ -854,7 +850,7 @@ impl<'a, C, NC, A> DeploymentMethods<'a, C, NC, A> { /// /// * `project` - ! The project ID for this request. /// * `deployment` - ! The name of the deployment for this request. - pub fn get(&self, project: &str, deployment: &str) -> DeploymentGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, deployment: &str) -> DeploymentGetCall<'a, C, A> { DeploymentGetCall { hub: self.hub, _project: project.to_string(), @@ -872,7 +868,7 @@ impl<'a, C, NC, A> DeploymentMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - ! The project ID for this request. - pub fn list(&self, project: &str) -> DeploymentListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> DeploymentListCall<'a, C, A> { DeploymentListCall { hub: self.hub, _project: project.to_string(), @@ -892,7 +888,7 @@ impl<'a, C, NC, A> DeploymentMethods<'a, C, NC, A> { /// /// * `project` - ! The project ID for this request. /// * `deployment` - ! The name of the deployment for this request. - pub fn delete(&self, project: &str, deployment: &str) -> DeploymentDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, deployment: &str) -> DeploymentDeleteCall<'a, C, A> { DeploymentDeleteCall { hub: self.hub, _project: project.to_string(), @@ -934,15 +930,15 @@ impl<'a, C, NC, A> DeploymentMethods<'a, C, NC, A> { /// let rb = hub.types(); /// # } /// ``` -pub struct TypeMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TypeMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Deploymentmanager, + hub: &'a Deploymentmanager, } -impl<'a, C, NC, A> MethodsBuilder for TypeMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TypeMethods<'a, C, A> {} -impl<'a, C, NC, A> TypeMethods<'a, C, NC, A> { +impl<'a, C, A> TypeMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -951,7 +947,7 @@ impl<'a, C, NC, A> TypeMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - ! The project ID for this request. - pub fn list(&self, project: &str) -> TypeListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> TypeListCall<'a, C, A> { TypeListCall { hub: self.hub, _project: project.to_string(), @@ -994,15 +990,15 @@ impl<'a, C, NC, A> TypeMethods<'a, C, NC, A> { /// let rb = hub.resources(); /// # } /// ``` -pub struct ResourceMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ResourceMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Deploymentmanager, + hub: &'a Deploymentmanager, } -impl<'a, C, NC, A> MethodsBuilder for ResourceMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ResourceMethods<'a, C, A> {} -impl<'a, C, NC, A> ResourceMethods<'a, C, NC, A> { +impl<'a, C, A> ResourceMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1013,7 +1009,7 @@ impl<'a, C, NC, A> ResourceMethods<'a, C, NC, A> { /// * `project` - ! The project ID for this request. /// * `deployment` - ! The name of the deployment for this request. /// * `resource` - ! The name of the resource for this request. - pub fn get(&self, project: &str, deployment: &str, resource: &str) -> ResourceGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, deployment: &str, resource: &str) -> ResourceGetCall<'a, C, A> { ResourceGetCall { hub: self.hub, _project: project.to_string(), @@ -1033,7 +1029,7 @@ impl<'a, C, NC, A> ResourceMethods<'a, C, NC, A> { /// /// * `project` - ! The project ID for this request. /// * `deployment` - ! The name of the deployment for this request. - pub fn list(&self, project: &str, deployment: &str) -> ResourceListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, deployment: &str) -> ResourceListCall<'a, C, A> { ResourceListCall { hub: self.hub, _project: project.to_string(), @@ -1077,15 +1073,15 @@ impl<'a, C, NC, A> ResourceMethods<'a, C, NC, A> { /// let rb = hub.manifests(); /// # } /// ``` -pub struct ManifestMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManifestMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Deploymentmanager, + hub: &'a Deploymentmanager, } -impl<'a, C, NC, A> MethodsBuilder for ManifestMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ManifestMethods<'a, C, A> {} -impl<'a, C, NC, A> ManifestMethods<'a, C, NC, A> { +impl<'a, C, A> ManifestMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1095,7 +1091,7 @@ impl<'a, C, NC, A> ManifestMethods<'a, C, NC, A> { /// /// * `project` - ! The project ID for this request. /// * `deployment` - ! The name of the deployment for this request. - pub fn list(&self, project: &str, deployment: &str) -> ManifestListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, deployment: &str) -> ManifestListCall<'a, C, A> { ManifestListCall { hub: self.hub, _project: project.to_string(), @@ -1117,7 +1113,7 @@ impl<'a, C, NC, A> ManifestMethods<'a, C, NC, A> { /// * `project` - ! The project ID for this request. /// * `deployment` - ! The name of the deployment for this request. /// * `manifest` - ! The name of the manifest for this request. - pub fn get(&self, project: &str, deployment: &str, manifest: &str) -> ManifestGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, deployment: &str, manifest: &str) -> ManifestGetCall<'a, C, A> { ManifestGetCall { hub: self.hub, _project: project.to_string(), @@ -1168,10 +1164,10 @@ impl<'a, C, NC, A> ManifestMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct OperationGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct OperationGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Deploymentmanager, + hub: &'a Deploymentmanager, _project: String, _operation: String, _delegate: Option<&'a mut Delegate>, @@ -1179,9 +1175,9 @@ pub struct OperationGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for OperationGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for OperationGetCall<'a, C, A> {} -impl<'a, C, NC, A> OperationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> OperationGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1314,7 +1310,7 @@ impl<'a, C, NC, A> OperationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// ! The project ID for this request. - pub fn project(mut self, new_value: &str) -> OperationGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> OperationGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1324,7 +1320,7 @@ impl<'a, C, NC, A> OperationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// ! The name of the operation for this request. - pub fn operation(mut self, new_value: &str) -> OperationGetCall<'a, C, NC, A> { + pub fn operation(mut self, new_value: &str) -> OperationGetCall<'a, C, A> { self._operation = new_value.to_string(); self } @@ -1335,7 +1331,7 @@ impl<'a, C, NC, A> OperationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> OperationGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> OperationGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1356,7 +1352,7 @@ impl<'a, C, NC, A> OperationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> OperationGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> OperationGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1373,7 +1369,7 @@ impl<'a, C, NC, A> OperationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> OperationGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> OperationGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1413,10 +1409,10 @@ impl<'a, C, NC, A> OperationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct OperationListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct OperationListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Deploymentmanager, + hub: &'a Deploymentmanager, _project: String, _page_token: Option, _max_results: Option, @@ -1425,9 +1421,9 @@ pub struct OperationListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for OperationListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for OperationListCall<'a, C, A> {} -impl<'a, C, NC, A> OperationListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> OperationListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1565,7 +1561,7 @@ impl<'a, C, NC, A> OperationListCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// ! The project ID for this request. - pub fn project(mut self, new_value: &str) -> OperationListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> OperationListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1573,7 +1569,7 @@ impl<'a, C, NC, A> OperationListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// ! Specifies a nextPageToken returned by a previous list request. This ! token can be used to request the next page of results from a previous ! list request. - pub fn page_token(mut self, new_value: &str) -> OperationListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> OperationListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -1581,7 +1577,7 @@ impl<'a, C, NC, A> OperationListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// ! Maximum count of results to be returned. ! Acceptable values are 0 to 100, inclusive. (Default: 50) - pub fn max_results(mut self, new_value: i32) -> OperationListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> OperationListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -1592,7 +1588,7 @@ impl<'a, C, NC, A> OperationListCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> OperationListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> OperationListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1613,7 +1609,7 @@ impl<'a, C, NC, A> OperationListCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> OperationListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> OperationListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1630,7 +1626,7 @@ impl<'a, C, NC, A> OperationListCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> OperationListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> OperationListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1674,10 +1670,10 @@ impl<'a, C, NC, A> OperationListCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct DeploymentInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DeploymentInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Deploymentmanager, + hub: &'a Deploymentmanager, _request: Deployment, _project: String, _delegate: Option<&'a mut Delegate>, @@ -1685,9 +1681,9 @@ pub struct DeploymentInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DeploymentInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DeploymentInsertCall<'a, C, A> {} -impl<'a, C, NC, A> DeploymentInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DeploymentInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1826,7 +1822,7 @@ impl<'a, C, NC, A> DeploymentInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Deployment) -> DeploymentInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Deployment) -> DeploymentInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1836,7 +1832,7 @@ impl<'a, C, NC, A> DeploymentInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// ! The project ID for this request. - pub fn project(mut self, new_value: &str) -> DeploymentInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> DeploymentInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1847,7 +1843,7 @@ impl<'a, C, NC, A> DeploymentInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeploymentInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeploymentInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1868,7 +1864,7 @@ impl<'a, C, NC, A> DeploymentInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DeploymentInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DeploymentInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1885,7 +1881,7 @@ impl<'a, C, NC, A> DeploymentInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DeploymentInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DeploymentInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1923,10 +1919,10 @@ impl<'a, C, NC, A> DeploymentInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct DeploymentGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DeploymentGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Deploymentmanager, + hub: &'a Deploymentmanager, _project: String, _deployment: String, _delegate: Option<&'a mut Delegate>, @@ -1934,9 +1930,9 @@ pub struct DeploymentGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DeploymentGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DeploymentGetCall<'a, C, A> {} -impl<'a, C, NC, A> DeploymentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DeploymentGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2069,7 +2065,7 @@ impl<'a, C, NC, A> DeploymentGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// ! The project ID for this request. - pub fn project(mut self, new_value: &str) -> DeploymentGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> DeploymentGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2079,7 +2075,7 @@ impl<'a, C, NC, A> DeploymentGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// ! The name of the deployment for this request. - pub fn deployment(mut self, new_value: &str) -> DeploymentGetCall<'a, C, NC, A> { + pub fn deployment(mut self, new_value: &str) -> DeploymentGetCall<'a, C, A> { self._deployment = new_value.to_string(); self } @@ -2090,7 +2086,7 @@ impl<'a, C, NC, A> DeploymentGetCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeploymentGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeploymentGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2111,7 +2107,7 @@ impl<'a, C, NC, A> DeploymentGetCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DeploymentGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DeploymentGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2128,7 +2124,7 @@ impl<'a, C, NC, A> DeploymentGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DeploymentGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DeploymentGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2168,10 +2164,10 @@ impl<'a, C, NC, A> DeploymentGetCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct DeploymentListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DeploymentListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Deploymentmanager, + hub: &'a Deploymentmanager, _project: String, _page_token: Option, _max_results: Option, @@ -2180,9 +2176,9 @@ pub struct DeploymentListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DeploymentListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DeploymentListCall<'a, C, A> {} -impl<'a, C, NC, A> DeploymentListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DeploymentListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2320,7 +2316,7 @@ impl<'a, C, NC, A> DeploymentListCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// ! The project ID for this request. - pub fn project(mut self, new_value: &str) -> DeploymentListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> DeploymentListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2328,7 +2324,7 @@ impl<'a, C, NC, A> DeploymentListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// ! Specifies a nextPageToken returned by a previous list request. This ! token can be used to request the next page of results from a previous ! list request. - pub fn page_token(mut self, new_value: &str) -> DeploymentListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> DeploymentListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2336,7 +2332,7 @@ impl<'a, C, NC, A> DeploymentListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// ! Maximum count of results to be returned. ! Acceptable values are 0 to 100, inclusive. (Default: 50) - pub fn max_results(mut self, new_value: i32) -> DeploymentListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> DeploymentListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2347,7 +2343,7 @@ impl<'a, C, NC, A> DeploymentListCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeploymentListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeploymentListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2368,7 +2364,7 @@ impl<'a, C, NC, A> DeploymentListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DeploymentListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DeploymentListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2385,7 +2381,7 @@ impl<'a, C, NC, A> DeploymentListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DeploymentListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DeploymentListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2423,10 +2419,10 @@ impl<'a, C, NC, A> DeploymentListCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct DeploymentDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DeploymentDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Deploymentmanager, + hub: &'a Deploymentmanager, _project: String, _deployment: String, _delegate: Option<&'a mut Delegate>, @@ -2434,9 +2430,9 @@ pub struct DeploymentDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DeploymentDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DeploymentDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> DeploymentDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DeploymentDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2569,7 +2565,7 @@ impl<'a, C, NC, A> DeploymentDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// ! The project ID for this request. - pub fn project(mut self, new_value: &str) -> DeploymentDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> DeploymentDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2579,7 +2575,7 @@ impl<'a, C, NC, A> DeploymentDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// ! The name of the deployment for this request. - pub fn deployment(mut self, new_value: &str) -> DeploymentDeleteCall<'a, C, NC, A> { + pub fn deployment(mut self, new_value: &str) -> DeploymentDeleteCall<'a, C, A> { self._deployment = new_value.to_string(); self } @@ -2590,7 +2586,7 @@ impl<'a, C, NC, A> DeploymentDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeploymentDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeploymentDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2611,7 +2607,7 @@ impl<'a, C, NC, A> DeploymentDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DeploymentDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DeploymentDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2628,7 +2624,7 @@ impl<'a, C, NC, A> DeploymentDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DeploymentDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DeploymentDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2668,10 +2664,10 @@ impl<'a, C, NC, A> DeploymentDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct TypeListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TypeListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Deploymentmanager, + hub: &'a Deploymentmanager, _project: String, _page_token: Option, _max_results: Option, @@ -2680,9 +2676,9 @@ pub struct TypeListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TypeListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TypeListCall<'a, C, A> {} -impl<'a, C, NC, A> TypeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TypeListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2820,7 +2816,7 @@ impl<'a, C, NC, A> TypeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// ! The project ID for this request. - pub fn project(mut self, new_value: &str) -> TypeListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TypeListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2828,7 +2824,7 @@ impl<'a, C, NC, A> TypeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// ! Specifies a nextPageToken returned by a previous list request. This ! token can be used to request the next page of results from a previous ! list request. - pub fn page_token(mut self, new_value: &str) -> TypeListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TypeListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2836,7 +2832,7 @@ impl<'a, C, NC, A> TypeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// ! Maximum count of results to be returned. ! Acceptable values are 0 to 100, inclusive. (Default: 50) - pub fn max_results(mut self, new_value: i32) -> TypeListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> TypeListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2847,7 +2843,7 @@ impl<'a, C, NC, A> TypeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TypeListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TypeListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2868,7 +2864,7 @@ impl<'a, C, NC, A> TypeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TypeListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TypeListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2885,7 +2881,7 @@ impl<'a, C, NC, A> TypeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TypeListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TypeListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2923,10 +2919,10 @@ impl<'a, C, NC, A> TypeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct ResourceGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ResourceGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Deploymentmanager, + hub: &'a Deploymentmanager, _project: String, _deployment: String, _resource: String, @@ -2935,9 +2931,9 @@ pub struct ResourceGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ResourceGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ResourceGetCall<'a, C, A> {} -impl<'a, C, NC, A> ResourceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ResourceGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3071,7 +3067,7 @@ impl<'a, C, NC, A> ResourceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// ! The project ID for this request. - pub fn project(mut self, new_value: &str) -> ResourceGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ResourceGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -3081,7 +3077,7 @@ impl<'a, C, NC, A> ResourceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// ! The name of the deployment for this request. - pub fn deployment(mut self, new_value: &str) -> ResourceGetCall<'a, C, NC, A> { + pub fn deployment(mut self, new_value: &str) -> ResourceGetCall<'a, C, A> { self._deployment = new_value.to_string(); self } @@ -3091,7 +3087,7 @@ impl<'a, C, NC, A> ResourceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// ! The name of the resource for this request. - pub fn resource(mut self, new_value: &str) -> ResourceGetCall<'a, C, NC, A> { + pub fn resource(mut self, new_value: &str) -> ResourceGetCall<'a, C, A> { self._resource = new_value.to_string(); self } @@ -3102,7 +3098,7 @@ impl<'a, C, NC, A> ResourceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ResourceGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ResourceGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3123,7 +3119,7 @@ impl<'a, C, NC, A> ResourceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ResourceGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ResourceGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3140,7 +3136,7 @@ impl<'a, C, NC, A> ResourceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ResourceGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ResourceGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3180,10 +3176,10 @@ impl<'a, C, NC, A> ResourceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct ResourceListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ResourceListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Deploymentmanager, + hub: &'a Deploymentmanager, _project: String, _deployment: String, _page_token: Option, @@ -3193,9 +3189,9 @@ pub struct ResourceListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ResourceListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ResourceListCall<'a, C, A> {} -impl<'a, C, NC, A> ResourceListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ResourceListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3334,7 +3330,7 @@ impl<'a, C, NC, A> ResourceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// ! The project ID for this request. - pub fn project(mut self, new_value: &str) -> ResourceListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ResourceListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -3344,7 +3340,7 @@ impl<'a, C, NC, A> ResourceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// ! The name of the deployment for this request. - pub fn deployment(mut self, new_value: &str) -> ResourceListCall<'a, C, NC, A> { + pub fn deployment(mut self, new_value: &str) -> ResourceListCall<'a, C, A> { self._deployment = new_value.to_string(); self } @@ -3352,7 +3348,7 @@ impl<'a, C, NC, A> ResourceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// ! Specifies a nextPageToken returned by a previous list request. This ! token can be used to request the next page of results from a previous ! list request. - pub fn page_token(mut self, new_value: &str) -> ResourceListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ResourceListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -3360,7 +3356,7 @@ impl<'a, C, NC, A> ResourceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// ! Maximum count of results to be returned. ! Acceptable values are 0 to 100, inclusive. (Default: 50) - pub fn max_results(mut self, new_value: i32) -> ResourceListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ResourceListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -3371,7 +3367,7 @@ impl<'a, C, NC, A> ResourceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ResourceListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ResourceListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3392,7 +3388,7 @@ impl<'a, C, NC, A> ResourceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ResourceListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ResourceListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3409,7 +3405,7 @@ impl<'a, C, NC, A> ResourceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ResourceListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ResourceListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3449,10 +3445,10 @@ impl<'a, C, NC, A> ResourceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct ManifestListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManifestListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Deploymentmanager, + hub: &'a Deploymentmanager, _project: String, _deployment: String, _page_token: Option, @@ -3462,9 +3458,9 @@ pub struct ManifestListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManifestListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManifestListCall<'a, C, A> {} -impl<'a, C, NC, A> ManifestListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManifestListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3603,7 +3599,7 @@ impl<'a, C, NC, A> ManifestListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// ! The project ID for this request. - pub fn project(mut self, new_value: &str) -> ManifestListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ManifestListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -3613,7 +3609,7 @@ impl<'a, C, NC, A> ManifestListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// ! The name of the deployment for this request. - pub fn deployment(mut self, new_value: &str) -> ManifestListCall<'a, C, NC, A> { + pub fn deployment(mut self, new_value: &str) -> ManifestListCall<'a, C, A> { self._deployment = new_value.to_string(); self } @@ -3621,7 +3617,7 @@ impl<'a, C, NC, A> ManifestListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// ! Specifies a nextPageToken returned by a previous list request. This ! token can be used to request the next page of results from a previous ! list request. - pub fn page_token(mut self, new_value: &str) -> ManifestListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ManifestListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -3629,7 +3625,7 @@ impl<'a, C, NC, A> ManifestListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// ! Maximum count of results to be returned. ! Acceptable values are 0 to 100, inclusive. (Default: 50) - pub fn max_results(mut self, new_value: i32) -> ManifestListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ManifestListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -3640,7 +3636,7 @@ impl<'a, C, NC, A> ManifestListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManifestListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManifestListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3661,7 +3657,7 @@ impl<'a, C, NC, A> ManifestListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManifestListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManifestListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3678,7 +3674,7 @@ impl<'a, C, NC, A> ManifestListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManifestListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManifestListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3716,10 +3712,10 @@ impl<'a, C, NC, A> ManifestListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct ManifestGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManifestGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Deploymentmanager, + hub: &'a Deploymentmanager, _project: String, _deployment: String, _manifest: String, @@ -3728,9 +3724,9 @@ pub struct ManifestGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManifestGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManifestGetCall<'a, C, A> {} -impl<'a, C, NC, A> ManifestGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManifestGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3864,7 +3860,7 @@ impl<'a, C, NC, A> ManifestGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// ! The project ID for this request. - pub fn project(mut self, new_value: &str) -> ManifestGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ManifestGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -3874,7 +3870,7 @@ impl<'a, C, NC, A> ManifestGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// ! The name of the deployment for this request. - pub fn deployment(mut self, new_value: &str) -> ManifestGetCall<'a, C, NC, A> { + pub fn deployment(mut self, new_value: &str) -> ManifestGetCall<'a, C, A> { self._deployment = new_value.to_string(); self } @@ -3884,7 +3880,7 @@ impl<'a, C, NC, A> ManifestGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// ! The name of the manifest for this request. - pub fn manifest(mut self, new_value: &str) -> ManifestGetCall<'a, C, NC, A> { + pub fn manifest(mut self, new_value: &str) -> ManifestGetCall<'a, C, A> { self._manifest = new_value.to_string(); self } @@ -3895,7 +3891,7 @@ impl<'a, C, NC, A> ManifestGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManifestGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManifestGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3916,7 +3912,7 @@ impl<'a, C, NC, A> ManifestGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManifestGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManifestGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3933,7 +3929,7 @@ impl<'a, C, NC, A> ManifestGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManifestGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManifestGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/dfareporting2/Cargo.toml b/gen/dfareporting2/Cargo.toml index 0205a202aab..6ef31d3aadc 100644 --- a/gen/dfareporting2/Cargo.toml +++ b/gen/dfareporting2/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-dfareporting2" -version = "0.1.4+20150326" +version = "0.1.5+20150326" authors = ["Sebastian Thiel "] description = "A complete library to interact with dfareporting (protocol v2.0)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/dfareporting2" homepage = "https://developers.google.com/doubleclick-advertisers/reporting/" -documentation = "http://byron.github.io/google-apis-rs/google-dfareporting2" +documentation = "http://byron.github.io/google-apis-rs/google_dfareporting2" license = "MIT" keywords = ["dfareporting", "google", "protocol", "web", "api"] diff --git a/gen/dfareporting2/README.md b/gen/dfareporting2/README.md index 28bb1a4eada..80fdc040d09 100644 --- a/gen/dfareporting2/README.md +++ b/gen/dfareporting2/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-dfareporting2` library allows access to all features of the *Google dfareporting* service. -This documentation was generated from *dfareporting* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *dfareporting:v2.0* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *dfareporting* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *dfareporting:v2.0* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *dfareporting* *v2* API can be found at the [official documentation site](https://developers.google.com/doubleclick-advertisers/reporting/). diff --git a/gen/dfareporting2/src/cmn.rs b/gen/dfareporting2/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/dfareporting2/src/cmn.rs +++ b/gen/dfareporting2/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/dfareporting2/src/lib.rs b/gen/dfareporting2/src/lib.rs index 09bb99e9a44..3b56197bf82 100644 --- a/gen/dfareporting2/src/lib.rs +++ b/gen/dfareporting2/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *dfareporting* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *dfareporting:v2.0* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *dfareporting* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *dfareporting:v2.0* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *dfareporting* *v2* API can be found at the //! [official documentation site](https://developers.google.com/doubleclick-advertisers/reporting/). @@ -305,7 +305,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -405,175 +404,172 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Dfareporting { +pub struct Dfareporting { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Dfareporting {} +impl<'a, C, A> Hub for Dfareporting {} -impl<'a, C, NC, A> Dfareporting - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Dfareporting + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Dfareporting { + pub fn new(client: C, authenticator: A) -> Dfareporting { Dfareporting { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn account_active_ad_summaries(&'a self) -> AccountActiveAdSummaryMethods<'a, C, NC, A> { + pub fn account_active_ad_summaries(&'a self) -> AccountActiveAdSummaryMethods<'a, C, A> { AccountActiveAdSummaryMethods { hub: &self } } - pub fn account_permission_groups(&'a self) -> AccountPermissionGroupMethods<'a, C, NC, A> { + pub fn account_permission_groups(&'a self) -> AccountPermissionGroupMethods<'a, C, A> { AccountPermissionGroupMethods { hub: &self } } - pub fn account_permissions(&'a self) -> AccountPermissionMethods<'a, C, NC, A> { + pub fn account_permissions(&'a self) -> AccountPermissionMethods<'a, C, A> { AccountPermissionMethods { hub: &self } } - pub fn account_user_profiles(&'a self) -> AccountUserProfileMethods<'a, C, NC, A> { + pub fn account_user_profiles(&'a self) -> AccountUserProfileMethods<'a, C, A> { AccountUserProfileMethods { hub: &self } } - pub fn accounts(&'a self) -> AccountMethods<'a, C, NC, A> { + pub fn accounts(&'a self) -> AccountMethods<'a, C, A> { AccountMethods { hub: &self } } - pub fn ads(&'a self) -> AdMethods<'a, C, NC, A> { + pub fn ads(&'a self) -> AdMethods<'a, C, A> { AdMethods { hub: &self } } - pub fn advertiser_groups(&'a self) -> AdvertiserGroupMethods<'a, C, NC, A> { + pub fn advertiser_groups(&'a self) -> AdvertiserGroupMethods<'a, C, A> { AdvertiserGroupMethods { hub: &self } } - pub fn advertisers(&'a self) -> AdvertiserMethods<'a, C, NC, A> { + pub fn advertisers(&'a self) -> AdvertiserMethods<'a, C, A> { AdvertiserMethods { hub: &self } } - pub fn browsers(&'a self) -> BrowserMethods<'a, C, NC, A> { + pub fn browsers(&'a self) -> BrowserMethods<'a, C, A> { BrowserMethods { hub: &self } } - pub fn campaign_creative_associations(&'a self) -> CampaignCreativeAssociationMethods<'a, C, NC, A> { + pub fn campaign_creative_associations(&'a self) -> CampaignCreativeAssociationMethods<'a, C, A> { CampaignCreativeAssociationMethods { hub: &self } } - pub fn campaigns(&'a self) -> CampaignMethods<'a, C, NC, A> { + pub fn campaigns(&'a self) -> CampaignMethods<'a, C, A> { CampaignMethods { hub: &self } } - pub fn change_logs(&'a self) -> ChangeLogMethods<'a, C, NC, A> { + pub fn change_logs(&'a self) -> ChangeLogMethods<'a, C, A> { ChangeLogMethods { hub: &self } } - pub fn cities(&'a self) -> CityMethods<'a, C, NC, A> { + pub fn cities(&'a self) -> CityMethods<'a, C, A> { CityMethods { hub: &self } } - pub fn connection_types(&'a self) -> ConnectionTypeMethods<'a, C, NC, A> { + pub fn connection_types(&'a self) -> ConnectionTypeMethods<'a, C, A> { ConnectionTypeMethods { hub: &self } } - pub fn content_categories(&'a self) -> ContentCategoryMethods<'a, C, NC, A> { + pub fn content_categories(&'a self) -> ContentCategoryMethods<'a, C, A> { ContentCategoryMethods { hub: &self } } - pub fn countries(&'a self) -> CountryMethods<'a, C, NC, A> { + pub fn countries(&'a self) -> CountryMethods<'a, C, A> { CountryMethods { hub: &self } } - pub fn creative_assets(&'a self) -> CreativeAssetMethods<'a, C, NC, A> { + pub fn creative_assets(&'a self) -> CreativeAssetMethods<'a, C, A> { CreativeAssetMethods { hub: &self } } - pub fn creative_field_values(&'a self) -> CreativeFieldValueMethods<'a, C, NC, A> { + pub fn creative_field_values(&'a self) -> CreativeFieldValueMethods<'a, C, A> { CreativeFieldValueMethods { hub: &self } } - pub fn creative_fields(&'a self) -> CreativeFieldMethods<'a, C, NC, A> { + pub fn creative_fields(&'a self) -> CreativeFieldMethods<'a, C, A> { CreativeFieldMethods { hub: &self } } - pub fn creative_groups(&'a self) -> CreativeGroupMethods<'a, C, NC, A> { + pub fn creative_groups(&'a self) -> CreativeGroupMethods<'a, C, A> { CreativeGroupMethods { hub: &self } } - pub fn creatives(&'a self) -> CreativeMethods<'a, C, NC, A> { + pub fn creatives(&'a self) -> CreativeMethods<'a, C, A> { CreativeMethods { hub: &self } } - pub fn dimension_values(&'a self) -> DimensionValueMethods<'a, C, NC, A> { + pub fn dimension_values(&'a self) -> DimensionValueMethods<'a, C, A> { DimensionValueMethods { hub: &self } } - pub fn directory_site_contacts(&'a self) -> DirectorySiteContactMethods<'a, C, NC, A> { + pub fn directory_site_contacts(&'a self) -> DirectorySiteContactMethods<'a, C, A> { DirectorySiteContactMethods { hub: &self } } - pub fn directory_sites(&'a self) -> DirectorySiteMethods<'a, C, NC, A> { + pub fn directory_sites(&'a self) -> DirectorySiteMethods<'a, C, A> { DirectorySiteMethods { hub: &self } } - pub fn event_tags(&'a self) -> EventTagMethods<'a, C, NC, A> { + pub fn event_tags(&'a self) -> EventTagMethods<'a, C, A> { EventTagMethods { hub: &self } } - pub fn files(&'a self) -> FileMethods<'a, C, NC, A> { + pub fn files(&'a self) -> FileMethods<'a, C, A> { FileMethods { hub: &self } } - pub fn floodlight_activities(&'a self) -> FloodlightActivityMethods<'a, C, NC, A> { + pub fn floodlight_activities(&'a self) -> FloodlightActivityMethods<'a, C, A> { FloodlightActivityMethods { hub: &self } } - pub fn floodlight_activity_groups(&'a self) -> FloodlightActivityGroupMethods<'a, C, NC, A> { + pub fn floodlight_activity_groups(&'a self) -> FloodlightActivityGroupMethods<'a, C, A> { FloodlightActivityGroupMethods { hub: &self } } - pub fn floodlight_configurations(&'a self) -> FloodlightConfigurationMethods<'a, C, NC, A> { + pub fn floodlight_configurations(&'a self) -> FloodlightConfigurationMethods<'a, C, A> { FloodlightConfigurationMethods { hub: &self } } - pub fn landing_pages(&'a self) -> LandingPageMethods<'a, C, NC, A> { + pub fn landing_pages(&'a self) -> LandingPageMethods<'a, C, A> { LandingPageMethods { hub: &self } } - pub fn metros(&'a self) -> MetroMethods<'a, C, NC, A> { + pub fn metros(&'a self) -> MetroMethods<'a, C, A> { MetroMethods { hub: &self } } - pub fn mobile_carriers(&'a self) -> MobileCarrierMethods<'a, C, NC, A> { + pub fn mobile_carriers(&'a self) -> MobileCarrierMethods<'a, C, A> { MobileCarrierMethods { hub: &self } } - pub fn operating_system_versions(&'a self) -> OperatingSystemVersionMethods<'a, C, NC, A> { + pub fn operating_system_versions(&'a self) -> OperatingSystemVersionMethods<'a, C, A> { OperatingSystemVersionMethods { hub: &self } } - pub fn operating_systems(&'a self) -> OperatingSystemMethods<'a, C, NC, A> { + pub fn operating_systems(&'a self) -> OperatingSystemMethods<'a, C, A> { OperatingSystemMethods { hub: &self } } - pub fn placement_groups(&'a self) -> PlacementGroupMethods<'a, C, NC, A> { + pub fn placement_groups(&'a self) -> PlacementGroupMethods<'a, C, A> { PlacementGroupMethods { hub: &self } } - pub fn placement_strategies(&'a self) -> PlacementStrategyMethods<'a, C, NC, A> { + pub fn placement_strategies(&'a self) -> PlacementStrategyMethods<'a, C, A> { PlacementStrategyMethods { hub: &self } } - pub fn placements(&'a self) -> PlacementMethods<'a, C, NC, A> { + pub fn placements(&'a self) -> PlacementMethods<'a, C, A> { PlacementMethods { hub: &self } } - pub fn platform_types(&'a self) -> PlatformTypeMethods<'a, C, NC, A> { + pub fn platform_types(&'a self) -> PlatformTypeMethods<'a, C, A> { PlatformTypeMethods { hub: &self } } - pub fn postal_codes(&'a self) -> PostalCodeMethods<'a, C, NC, A> { + pub fn postal_codes(&'a self) -> PostalCodeMethods<'a, C, A> { PostalCodeMethods { hub: &self } } - pub fn regions(&'a self) -> RegionMethods<'a, C, NC, A> { + pub fn regions(&'a self) -> RegionMethods<'a, C, A> { RegionMethods { hub: &self } } - pub fn reports(&'a self) -> ReportMethods<'a, C, NC, A> { + pub fn reports(&'a self) -> ReportMethods<'a, C, A> { ReportMethods { hub: &self } } - pub fn sites(&'a self) -> SiteMethods<'a, C, NC, A> { + pub fn sites(&'a self) -> SiteMethods<'a, C, A> { SiteMethods { hub: &self } } - pub fn sizes(&'a self) -> SizeMethods<'a, C, NC, A> { + pub fn sizes(&'a self) -> SizeMethods<'a, C, A> { SizeMethods { hub: &self } } - pub fn subaccounts(&'a self) -> SubaccountMethods<'a, C, NC, A> { + pub fn subaccounts(&'a self) -> SubaccountMethods<'a, C, A> { SubaccountMethods { hub: &self } } - pub fn user_profiles(&'a self) -> UserProfileMethods<'a, C, NC, A> { + pub fn user_profiles(&'a self) -> UserProfileMethods<'a, C, A> { UserProfileMethods { hub: &self } } - pub fn user_role_permission_groups(&'a self) -> UserRolePermissionGroupMethods<'a, C, NC, A> { + pub fn user_role_permission_groups(&'a self) -> UserRolePermissionGroupMethods<'a, C, A> { UserRolePermissionGroupMethods { hub: &self } } - pub fn user_role_permissions(&'a self) -> UserRolePermissionMethods<'a, C, NC, A> { + pub fn user_role_permissions(&'a self) -> UserRolePermissionMethods<'a, C, A> { UserRolePermissionMethods { hub: &self } } - pub fn user_roles(&'a self) -> UserRoleMethods<'a, C, NC, A> { + pub fn user_roles(&'a self) -> UserRoleMethods<'a, C, A> { UserRoleMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -6125,15 +6121,15 @@ impl ResponseResult for UserRolesListResponse {} /// let rb = hub.user_role_permission_groups(); /// # } /// ``` -pub struct UserRolePermissionGroupMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserRolePermissionGroupMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for UserRolePermissionGroupMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for UserRolePermissionGroupMethods<'a, C, A> {} -impl<'a, C, NC, A> UserRolePermissionGroupMethods<'a, C, NC, A> { +impl<'a, C, A> UserRolePermissionGroupMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -6143,7 +6139,7 @@ impl<'a, C, NC, A> UserRolePermissionGroupMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - User role permission group ID. - pub fn get(&self, profile_id: &str, id: &str) -> UserRolePermissionGroupGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> UserRolePermissionGroupGetCall<'a, C, A> { UserRolePermissionGroupGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -6161,7 +6157,7 @@ impl<'a, C, NC, A> UserRolePermissionGroupMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> UserRolePermissionGroupListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> UserRolePermissionGroupListCall<'a, C, A> { UserRolePermissionGroupListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -6202,15 +6198,15 @@ impl<'a, C, NC, A> UserRolePermissionGroupMethods<'a, C, NC, A> { /// let rb = hub.platform_types(); /// # } /// ``` -pub struct PlatformTypeMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlatformTypeMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for PlatformTypeMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PlatformTypeMethods<'a, C, A> {} -impl<'a, C, NC, A> PlatformTypeMethods<'a, C, NC, A> { +impl<'a, C, A> PlatformTypeMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -6219,7 +6215,7 @@ impl<'a, C, NC, A> PlatformTypeMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> PlatformTypeListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> PlatformTypeListCall<'a, C, A> { PlatformTypeListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -6260,15 +6256,15 @@ impl<'a, C, NC, A> PlatformTypeMethods<'a, C, NC, A> { /// let rb = hub.creative_fields(); /// # } /// ``` -pub struct CreativeFieldMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeFieldMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for CreativeFieldMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CreativeFieldMethods<'a, C, A> {} -impl<'a, C, NC, A> CreativeFieldMethods<'a, C, NC, A> { +impl<'a, C, A> CreativeFieldMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -6278,7 +6274,7 @@ impl<'a, C, NC, A> CreativeFieldMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn update(&self, request: &CreativeField, profile_id: &str) -> CreativeFieldUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &CreativeField, profile_id: &str) -> CreativeFieldUpdateCall<'a, C, A> { CreativeFieldUpdateCall { hub: self.hub, _request: request.clone(), @@ -6296,7 +6292,7 @@ impl<'a, C, NC, A> CreativeFieldMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> CreativeFieldListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> CreativeFieldListCall<'a, C, A> { CreativeFieldListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -6321,7 +6317,7 @@ impl<'a, C, NC, A> CreativeFieldMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Creative Field ID - pub fn delete(&self, profile_id: &str, id: &str) -> CreativeFieldDeleteCall<'a, C, NC, A> { + pub fn delete(&self, profile_id: &str, id: &str) -> CreativeFieldDeleteCall<'a, C, A> { CreativeFieldDeleteCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -6340,7 +6336,7 @@ impl<'a, C, NC, A> CreativeFieldMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Creative Field ID - pub fn get(&self, profile_id: &str, id: &str) -> CreativeFieldGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> CreativeFieldGetCall<'a, C, A> { CreativeFieldGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -6359,7 +6355,7 @@ impl<'a, C, NC, A> CreativeFieldMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn insert(&self, request: &CreativeField, profile_id: &str) -> CreativeFieldInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &CreativeField, profile_id: &str) -> CreativeFieldInsertCall<'a, C, A> { CreativeFieldInsertCall { hub: self.hub, _request: request.clone(), @@ -6379,7 +6375,7 @@ impl<'a, C, NC, A> CreativeFieldMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `id` - Creative Field ID - pub fn patch(&self, request: &CreativeField, profile_id: &str, id: &str) -> CreativeFieldPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &CreativeField, profile_id: &str, id: &str) -> CreativeFieldPatchCall<'a, C, A> { CreativeFieldPatchCall { hub: self.hub, _request: request.clone(), @@ -6422,15 +6418,15 @@ impl<'a, C, NC, A> CreativeFieldMethods<'a, C, NC, A> { /// let rb = hub.user_roles(); /// # } /// ``` -pub struct UserRoleMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserRoleMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for UserRoleMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for UserRoleMethods<'a, C, A> {} -impl<'a, C, NC, A> UserRoleMethods<'a, C, NC, A> { +impl<'a, C, A> UserRoleMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -6440,7 +6436,7 @@ impl<'a, C, NC, A> UserRoleMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn insert(&self, request: &UserRole, profile_id: &str) -> UserRoleInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &UserRole, profile_id: &str) -> UserRoleInsertCall<'a, C, A> { UserRoleInsertCall { hub: self.hub, _request: request.clone(), @@ -6459,7 +6455,7 @@ impl<'a, C, NC, A> UserRoleMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - User role ID. - pub fn get(&self, profile_id: &str, id: &str) -> UserRoleGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> UserRoleGetCall<'a, C, A> { UserRoleGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -6478,7 +6474,7 @@ impl<'a, C, NC, A> UserRoleMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn update(&self, request: &UserRole, profile_id: &str) -> UserRoleUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &UserRole, profile_id: &str) -> UserRoleUpdateCall<'a, C, A> { UserRoleUpdateCall { hub: self.hub, _request: request.clone(), @@ -6497,7 +6493,7 @@ impl<'a, C, NC, A> UserRoleMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - User role ID. - pub fn delete(&self, profile_id: &str, id: &str) -> UserRoleDeleteCall<'a, C, NC, A> { + pub fn delete(&self, profile_id: &str, id: &str) -> UserRoleDeleteCall<'a, C, A> { UserRoleDeleteCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -6517,7 +6513,7 @@ impl<'a, C, NC, A> UserRoleMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `id` - User role ID. - pub fn patch(&self, request: &UserRole, profile_id: &str, id: &str) -> UserRolePatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &UserRole, profile_id: &str, id: &str) -> UserRolePatchCall<'a, C, A> { UserRolePatchCall { hub: self.hub, _request: request.clone(), @@ -6536,7 +6532,7 @@ impl<'a, C, NC, A> UserRoleMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> UserRoleListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> UserRoleListCall<'a, C, A> { UserRoleListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -6585,15 +6581,15 @@ impl<'a, C, NC, A> UserRoleMethods<'a, C, NC, A> { /// let rb = hub.operating_system_versions(); /// # } /// ``` -pub struct OperatingSystemVersionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct OperatingSystemVersionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for OperatingSystemVersionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for OperatingSystemVersionMethods<'a, C, A> {} -impl<'a, C, NC, A> OperatingSystemVersionMethods<'a, C, NC, A> { +impl<'a, C, A> OperatingSystemVersionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -6602,7 +6598,7 @@ impl<'a, C, NC, A> OperatingSystemVersionMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> OperatingSystemVersionListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> OperatingSystemVersionListCall<'a, C, A> { OperatingSystemVersionListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -6643,15 +6639,15 @@ impl<'a, C, NC, A> OperatingSystemVersionMethods<'a, C, NC, A> { /// let rb = hub.landing_pages(); /// # } /// ``` -pub struct LandingPageMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LandingPageMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for LandingPageMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for LandingPageMethods<'a, C, A> {} -impl<'a, C, NC, A> LandingPageMethods<'a, C, NC, A> { +impl<'a, C, A> LandingPageMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -6662,7 +6658,7 @@ impl<'a, C, NC, A> LandingPageMethods<'a, C, NC, A> { /// * `profileId` - User profile ID associated with this request. /// * `campaignId` - Landing page campaign ID. /// * `id` - Landing page ID. - pub fn get(&self, profile_id: &str, campaign_id: &str, id: &str) -> LandingPageGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, campaign_id: &str, id: &str) -> LandingPageGetCall<'a, C, A> { LandingPageGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -6683,7 +6679,7 @@ impl<'a, C, NC, A> LandingPageMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `campaignId` - Landing page campaign ID. - pub fn update(&self, request: &LandingPage, profile_id: &str, campaign_id: &str) -> LandingPageUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &LandingPage, profile_id: &str, campaign_id: &str) -> LandingPageUpdateCall<'a, C, A> { LandingPageUpdateCall { hub: self.hub, _request: request.clone(), @@ -6703,7 +6699,7 @@ impl<'a, C, NC, A> LandingPageMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `campaignId` - Landing page campaign ID. - pub fn list(&self, profile_id: &str, campaign_id: &str) -> LandingPageListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str, campaign_id: &str) -> LandingPageListCall<'a, C, A> { LandingPageListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -6723,7 +6719,7 @@ impl<'a, C, NC, A> LandingPageMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `campaignId` - Landing page campaign ID. - pub fn insert(&self, request: &LandingPage, profile_id: &str, campaign_id: &str) -> LandingPageInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &LandingPage, profile_id: &str, campaign_id: &str) -> LandingPageInsertCall<'a, C, A> { LandingPageInsertCall { hub: self.hub, _request: request.clone(), @@ -6745,7 +6741,7 @@ impl<'a, C, NC, A> LandingPageMethods<'a, C, NC, A> { /// * `profileId` - User profile ID associated with this request. /// * `campaignId` - Landing page campaign ID. /// * `id` - Landing page ID. - pub fn patch(&self, request: &LandingPage, profile_id: &str, campaign_id: &str, id: &str) -> LandingPagePatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &LandingPage, profile_id: &str, campaign_id: &str, id: &str) -> LandingPagePatchCall<'a, C, A> { LandingPagePatchCall { hub: self.hub, _request: request.clone(), @@ -6767,7 +6763,7 @@ impl<'a, C, NC, A> LandingPageMethods<'a, C, NC, A> { /// * `profileId` - User profile ID associated with this request. /// * `campaignId` - Landing page campaign ID. /// * `id` - Landing page ID. - pub fn delete(&self, profile_id: &str, campaign_id: &str, id: &str) -> LandingPageDeleteCall<'a, C, NC, A> { + pub fn delete(&self, profile_id: &str, campaign_id: &str, id: &str) -> LandingPageDeleteCall<'a, C, A> { LandingPageDeleteCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -6810,15 +6806,15 @@ impl<'a, C, NC, A> LandingPageMethods<'a, C, NC, A> { /// let rb = hub.campaign_creative_associations(); /// # } /// ``` -pub struct CampaignCreativeAssociationMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CampaignCreativeAssociationMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for CampaignCreativeAssociationMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CampaignCreativeAssociationMethods<'a, C, A> {} -impl<'a, C, NC, A> CampaignCreativeAssociationMethods<'a, C, NC, A> { +impl<'a, C, A> CampaignCreativeAssociationMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -6829,7 +6825,7 @@ impl<'a, C, NC, A> CampaignCreativeAssociationMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `campaignId` - Campaign ID in this association. - pub fn insert(&self, request: &CampaignCreativeAssociation, profile_id: &str, campaign_id: &str) -> CampaignCreativeAssociationInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &CampaignCreativeAssociation, profile_id: &str, campaign_id: &str) -> CampaignCreativeAssociationInsertCall<'a, C, A> { CampaignCreativeAssociationInsertCall { hub: self.hub, _request: request.clone(), @@ -6849,7 +6845,7 @@ impl<'a, C, NC, A> CampaignCreativeAssociationMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `campaignId` - Campaign ID in this association. - pub fn list(&self, profile_id: &str, campaign_id: &str) -> CampaignCreativeAssociationListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str, campaign_id: &str) -> CampaignCreativeAssociationListCall<'a, C, A> { CampaignCreativeAssociationListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -6894,15 +6890,15 @@ impl<'a, C, NC, A> CampaignCreativeAssociationMethods<'a, C, NC, A> { /// let rb = hub.change_logs(); /// # } /// ``` -pub struct ChangeLogMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChangeLogMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for ChangeLogMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ChangeLogMethods<'a, C, A> {} -impl<'a, C, NC, A> ChangeLogMethods<'a, C, NC, A> { +impl<'a, C, A> ChangeLogMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -6911,7 +6907,7 @@ impl<'a, C, NC, A> ChangeLogMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> ChangeLogListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> ChangeLogListCall<'a, C, A> { ChangeLogListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -6939,7 +6935,7 @@ impl<'a, C, NC, A> ChangeLogMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Change log ID. - pub fn get(&self, profile_id: &str, id: &str) -> ChangeLogGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> ChangeLogGetCall<'a, C, A> { ChangeLogGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -6981,15 +6977,15 @@ impl<'a, C, NC, A> ChangeLogMethods<'a, C, NC, A> { /// let rb = hub.accounts(); /// # } /// ``` -pub struct AccountMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for AccountMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AccountMethods<'a, C, A> {} -impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { +impl<'a, C, A> AccountMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -6999,7 +6995,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Account ID. - pub fn get(&self, profile_id: &str, id: &str) -> AccountGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> AccountGetCall<'a, C, A> { AccountGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -7017,7 +7013,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> AccountListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> AccountListCall<'a, C, A> { AccountListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -7042,7 +7038,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn update(&self, request: &Account, profile_id: &str) -> AccountUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Account, profile_id: &str) -> AccountUpdateCall<'a, C, A> { AccountUpdateCall { hub: self.hub, _request: request.clone(), @@ -7062,7 +7058,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `id` - Account ID. - pub fn patch(&self, request: &Account, profile_id: &str, id: &str) -> AccountPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Account, profile_id: &str, id: &str) -> AccountPatchCall<'a, C, A> { AccountPatchCall { hub: self.hub, _request: request.clone(), @@ -7105,15 +7101,15 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// let rb = hub.postal_codes(); /// # } /// ``` -pub struct PostalCodeMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PostalCodeMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for PostalCodeMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PostalCodeMethods<'a, C, A> {} -impl<'a, C, NC, A> PostalCodeMethods<'a, C, NC, A> { +impl<'a, C, A> PostalCodeMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -7122,7 +7118,7 @@ impl<'a, C, NC, A> PostalCodeMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> PostalCodeListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> PostalCodeListCall<'a, C, A> { PostalCodeListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -7163,15 +7159,15 @@ impl<'a, C, NC, A> PostalCodeMethods<'a, C, NC, A> { /// let rb = hub.advertisers(); /// # } /// ``` -pub struct AdvertiserMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdvertiserMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for AdvertiserMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AdvertiserMethods<'a, C, A> {} -impl<'a, C, NC, A> AdvertiserMethods<'a, C, NC, A> { +impl<'a, C, A> AdvertiserMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -7181,7 +7177,7 @@ impl<'a, C, NC, A> AdvertiserMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn insert(&self, request: &Advertiser, profile_id: &str) -> AdvertiserInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Advertiser, profile_id: &str) -> AdvertiserInsertCall<'a, C, A> { AdvertiserInsertCall { hub: self.hub, _request: request.clone(), @@ -7201,7 +7197,7 @@ impl<'a, C, NC, A> AdvertiserMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `id` - Advertiser ID. - pub fn patch(&self, request: &Advertiser, profile_id: &str, id: &str) -> AdvertiserPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Advertiser, profile_id: &str, id: &str) -> AdvertiserPatchCall<'a, C, A> { AdvertiserPatchCall { hub: self.hub, _request: request.clone(), @@ -7220,7 +7216,7 @@ impl<'a, C, NC, A> AdvertiserMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> AdvertiserListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> AdvertiserListCall<'a, C, A> { AdvertiserListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -7250,7 +7246,7 @@ impl<'a, C, NC, A> AdvertiserMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn update(&self, request: &Advertiser, profile_id: &str) -> AdvertiserUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Advertiser, profile_id: &str) -> AdvertiserUpdateCall<'a, C, A> { AdvertiserUpdateCall { hub: self.hub, _request: request.clone(), @@ -7269,7 +7265,7 @@ impl<'a, C, NC, A> AdvertiserMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Advertiser ID. - pub fn get(&self, profile_id: &str, id: &str) -> AdvertiserGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> AdvertiserGetCall<'a, C, A> { AdvertiserGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -7311,15 +7307,15 @@ impl<'a, C, NC, A> AdvertiserMethods<'a, C, NC, A> { /// let rb = hub.dimension_values(); /// # } /// ``` -pub struct DimensionValueMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DimensionValueMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for DimensionValueMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for DimensionValueMethods<'a, C, A> {} -impl<'a, C, NC, A> DimensionValueMethods<'a, C, NC, A> { +impl<'a, C, A> DimensionValueMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -7329,7 +7325,7 @@ impl<'a, C, NC, A> DimensionValueMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - The DFA user profile ID. - pub fn query(&self, request: &DimensionValueRequest, profile_id: &str) -> DimensionValueQueryCall<'a, C, NC, A> { + pub fn query(&self, request: &DimensionValueRequest, profile_id: &str) -> DimensionValueQueryCall<'a, C, A> { DimensionValueQueryCall { hub: self.hub, _request: request.clone(), @@ -7373,15 +7369,15 @@ impl<'a, C, NC, A> DimensionValueMethods<'a, C, NC, A> { /// let rb = hub.floodlight_activity_groups(); /// # } /// ``` -pub struct FloodlightActivityGroupMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FloodlightActivityGroupMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for FloodlightActivityGroupMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for FloodlightActivityGroupMethods<'a, C, A> {} -impl<'a, C, NC, A> FloodlightActivityGroupMethods<'a, C, NC, A> { +impl<'a, C, A> FloodlightActivityGroupMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -7391,7 +7387,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Floodlight activity Group ID. - pub fn delete(&self, profile_id: &str, id: &str) -> FloodlightActivityGroupDeleteCall<'a, C, NC, A> { + pub fn delete(&self, profile_id: &str, id: &str) -> FloodlightActivityGroupDeleteCall<'a, C, A> { FloodlightActivityGroupDeleteCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -7410,7 +7406,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Floodlight activity Group ID. - pub fn get(&self, profile_id: &str, id: &str) -> FloodlightActivityGroupGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> FloodlightActivityGroupGetCall<'a, C, A> { FloodlightActivityGroupGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -7430,7 +7426,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `id` - Floodlight activity Group ID. - pub fn patch(&self, request: &FloodlightActivityGroup, profile_id: &str, id: &str) -> FloodlightActivityGroupPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &FloodlightActivityGroup, profile_id: &str, id: &str) -> FloodlightActivityGroupPatchCall<'a, C, A> { FloodlightActivityGroupPatchCall { hub: self.hub, _request: request.clone(), @@ -7449,7 +7445,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> FloodlightActivityGroupListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> FloodlightActivityGroupListCall<'a, C, A> { FloodlightActivityGroupListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -7476,7 +7472,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn insert(&self, request: &FloodlightActivityGroup, profile_id: &str) -> FloodlightActivityGroupInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &FloodlightActivityGroup, profile_id: &str) -> FloodlightActivityGroupInsertCall<'a, C, A> { FloodlightActivityGroupInsertCall { hub: self.hub, _request: request.clone(), @@ -7495,7 +7491,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn update(&self, request: &FloodlightActivityGroup, profile_id: &str) -> FloodlightActivityGroupUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &FloodlightActivityGroup, profile_id: &str) -> FloodlightActivityGroupUpdateCall<'a, C, A> { FloodlightActivityGroupUpdateCall { hub: self.hub, _request: request.clone(), @@ -7537,15 +7533,15 @@ impl<'a, C, NC, A> FloodlightActivityGroupMethods<'a, C, NC, A> { /// let rb = hub.metros(); /// # } /// ``` -pub struct MetroMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MetroMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for MetroMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for MetroMethods<'a, C, A> {} -impl<'a, C, NC, A> MetroMethods<'a, C, NC, A> { +impl<'a, C, A> MetroMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -7554,7 +7550,7 @@ impl<'a, C, NC, A> MetroMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> MetroListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> MetroListCall<'a, C, A> { MetroListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -7595,15 +7591,15 @@ impl<'a, C, NC, A> MetroMethods<'a, C, NC, A> { /// let rb = hub.directory_site_contacts(); /// # } /// ``` -pub struct DirectorySiteContactMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DirectorySiteContactMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for DirectorySiteContactMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for DirectorySiteContactMethods<'a, C, A> {} -impl<'a, C, NC, A> DirectorySiteContactMethods<'a, C, NC, A> { +impl<'a, C, A> DirectorySiteContactMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -7613,7 +7609,7 @@ impl<'a, C, NC, A> DirectorySiteContactMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Directory site contact ID. - pub fn get(&self, profile_id: &str, id: &str) -> DirectorySiteContactGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> DirectorySiteContactGetCall<'a, C, A> { DirectorySiteContactGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -7631,7 +7627,7 @@ impl<'a, C, NC, A> DirectorySiteContactMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> DirectorySiteContactListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> DirectorySiteContactListCall<'a, C, A> { DirectorySiteContactListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -7679,20 +7675,20 @@ impl<'a, C, NC, A> DirectorySiteContactMethods<'a, C, NC, A> { /// let rb = hub.user_profiles(); /// # } /// ``` -pub struct UserProfileMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserProfileMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for UserProfileMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for UserProfileMethods<'a, C, A> {} -impl<'a, C, NC, A> UserProfileMethods<'a, C, NC, A> { +impl<'a, C, A> UserProfileMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Retrieves list of user profiles for a user. - pub fn list(&self) -> UserProfileListCall<'a, C, NC, A> { + pub fn list(&self) -> UserProfileListCall<'a, C, A> { UserProfileListCall { hub: self.hub, _delegate: Default::default(), @@ -7708,7 +7704,7 @@ impl<'a, C, NC, A> UserProfileMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - The user profile ID. - pub fn get(&self, profile_id: &str) -> UserProfileGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str) -> UserProfileGetCall<'a, C, A> { UserProfileGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -7749,15 +7745,15 @@ impl<'a, C, NC, A> UserProfileMethods<'a, C, NC, A> { /// let rb = hub.ads(); /// # } /// ``` -pub struct AdMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for AdMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AdMethods<'a, C, A> {} -impl<'a, C, NC, A> AdMethods<'a, C, NC, A> { +impl<'a, C, A> AdMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -7768,7 +7764,7 @@ impl<'a, C, NC, A> AdMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `id` - Ad ID. - pub fn patch(&self, request: &Ad, profile_id: &str, id: &str) -> AdPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Ad, profile_id: &str, id: &str) -> AdPatchCall<'a, C, A> { AdPatchCall { hub: self.hub, _request: request.clone(), @@ -7788,7 +7784,7 @@ impl<'a, C, NC, A> AdMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn insert(&self, request: &Ad, profile_id: &str) -> AdInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Ad, profile_id: &str) -> AdInsertCall<'a, C, A> { AdInsertCall { hub: self.hub, _request: request.clone(), @@ -7806,7 +7802,7 @@ impl<'a, C, NC, A> AdMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> AdListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> AdListCall<'a, C, A> { AdListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -7848,7 +7844,7 @@ impl<'a, C, NC, A> AdMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Ad ID. - pub fn get(&self, profile_id: &str, id: &str) -> AdGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> AdGetCall<'a, C, A> { AdGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -7867,7 +7863,7 @@ impl<'a, C, NC, A> AdMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn update(&self, request: &Ad, profile_id: &str) -> AdUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Ad, profile_id: &str) -> AdUpdateCall<'a, C, A> { AdUpdateCall { hub: self.hub, _request: request.clone(), @@ -7909,15 +7905,15 @@ impl<'a, C, NC, A> AdMethods<'a, C, NC, A> { /// let rb = hub.account_permissions(); /// # } /// ``` -pub struct AccountPermissionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountPermissionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for AccountPermissionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AccountPermissionMethods<'a, C, A> {} -impl<'a, C, NC, A> AccountPermissionMethods<'a, C, NC, A> { +impl<'a, C, A> AccountPermissionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -7927,7 +7923,7 @@ impl<'a, C, NC, A> AccountPermissionMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Account permission ID. - pub fn get(&self, profile_id: &str, id: &str) -> AccountPermissionGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> AccountPermissionGetCall<'a, C, A> { AccountPermissionGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -7945,7 +7941,7 @@ impl<'a, C, NC, A> AccountPermissionMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> AccountPermissionListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> AccountPermissionListCall<'a, C, A> { AccountPermissionListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -7986,15 +7982,15 @@ impl<'a, C, NC, A> AccountPermissionMethods<'a, C, NC, A> { /// let rb = hub.connection_types(); /// # } /// ``` -pub struct ConnectionTypeMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ConnectionTypeMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for ConnectionTypeMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ConnectionTypeMethods<'a, C, A> {} -impl<'a, C, NC, A> ConnectionTypeMethods<'a, C, NC, A> { +impl<'a, C, A> ConnectionTypeMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -8003,7 +7999,7 @@ impl<'a, C, NC, A> ConnectionTypeMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> ConnectionTypeListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> ConnectionTypeListCall<'a, C, A> { ConnectionTypeListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -8044,15 +8040,15 @@ impl<'a, C, NC, A> ConnectionTypeMethods<'a, C, NC, A> { /// let rb = hub.advertiser_groups(); /// # } /// ``` -pub struct AdvertiserGroupMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdvertiserGroupMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for AdvertiserGroupMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AdvertiserGroupMethods<'a, C, A> {} -impl<'a, C, NC, A> AdvertiserGroupMethods<'a, C, NC, A> { +impl<'a, C, A> AdvertiserGroupMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -8062,7 +8058,7 @@ impl<'a, C, NC, A> AdvertiserGroupMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Advertiser group ID. - pub fn get(&self, profile_id: &str, id: &str) -> AdvertiserGroupGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> AdvertiserGroupGetCall<'a, C, A> { AdvertiserGroupGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -8080,7 +8076,7 @@ impl<'a, C, NC, A> AdvertiserGroupMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> AdvertiserGroupListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> AdvertiserGroupListCall<'a, C, A> { AdvertiserGroupListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -8104,7 +8100,7 @@ impl<'a, C, NC, A> AdvertiserGroupMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn insert(&self, request: &AdvertiserGroup, profile_id: &str) -> AdvertiserGroupInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &AdvertiserGroup, profile_id: &str) -> AdvertiserGroupInsertCall<'a, C, A> { AdvertiserGroupInsertCall { hub: self.hub, _request: request.clone(), @@ -8123,7 +8119,7 @@ impl<'a, C, NC, A> AdvertiserGroupMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn update(&self, request: &AdvertiserGroup, profile_id: &str) -> AdvertiserGroupUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &AdvertiserGroup, profile_id: &str) -> AdvertiserGroupUpdateCall<'a, C, A> { AdvertiserGroupUpdateCall { hub: self.hub, _request: request.clone(), @@ -8143,7 +8139,7 @@ impl<'a, C, NC, A> AdvertiserGroupMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `id` - Advertiser group ID. - pub fn patch(&self, request: &AdvertiserGroup, profile_id: &str, id: &str) -> AdvertiserGroupPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &AdvertiserGroup, profile_id: &str, id: &str) -> AdvertiserGroupPatchCall<'a, C, A> { AdvertiserGroupPatchCall { hub: self.hub, _request: request.clone(), @@ -8163,7 +8159,7 @@ impl<'a, C, NC, A> AdvertiserGroupMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Advertiser group ID. - pub fn delete(&self, profile_id: &str, id: &str) -> AdvertiserGroupDeleteCall<'a, C, NC, A> { + pub fn delete(&self, profile_id: &str, id: &str) -> AdvertiserGroupDeleteCall<'a, C, A> { AdvertiserGroupDeleteCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -8205,15 +8201,15 @@ impl<'a, C, NC, A> AdvertiserGroupMethods<'a, C, NC, A> { /// let rb = hub.sites(); /// # } /// ``` -pub struct SiteMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SiteMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for SiteMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for SiteMethods<'a, C, A> {} -impl<'a, C, NC, A> SiteMethods<'a, C, NC, A> { +impl<'a, C, A> SiteMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -8223,7 +8219,7 @@ impl<'a, C, NC, A> SiteMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn insert(&self, request: &Site, profile_id: &str) -> SiteInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Site, profile_id: &str) -> SiteInsertCall<'a, C, A> { SiteInsertCall { hub: self.hub, _request: request.clone(), @@ -8242,7 +8238,7 @@ impl<'a, C, NC, A> SiteMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Site ID. - pub fn get(&self, profile_id: &str, id: &str) -> SiteGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> SiteGetCall<'a, C, A> { SiteGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -8260,7 +8256,7 @@ impl<'a, C, NC, A> SiteMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> SiteListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> SiteListCall<'a, C, A> { SiteListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -8293,7 +8289,7 @@ impl<'a, C, NC, A> SiteMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn update(&self, request: &Site, profile_id: &str) -> SiteUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Site, profile_id: &str) -> SiteUpdateCall<'a, C, A> { SiteUpdateCall { hub: self.hub, _request: request.clone(), @@ -8313,7 +8309,7 @@ impl<'a, C, NC, A> SiteMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `id` - Site ID. - pub fn patch(&self, request: &Site, profile_id: &str, id: &str) -> SitePatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Site, profile_id: &str, id: &str) -> SitePatchCall<'a, C, A> { SitePatchCall { hub: self.hub, _request: request.clone(), @@ -8356,15 +8352,15 @@ impl<'a, C, NC, A> SiteMethods<'a, C, NC, A> { /// let rb = hub.floodlight_activities(); /// # } /// ``` -pub struct FloodlightActivityMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FloodlightActivityMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for FloodlightActivityMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for FloodlightActivityMethods<'a, C, A> {} -impl<'a, C, NC, A> FloodlightActivityMethods<'a, C, NC, A> { +impl<'a, C, A> FloodlightActivityMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -8374,7 +8370,7 @@ impl<'a, C, NC, A> FloodlightActivityMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Floodlight activity ID. - pub fn get(&self, profile_id: &str, id: &str) -> FloodlightActivityGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> FloodlightActivityGetCall<'a, C, A> { FloodlightActivityGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -8392,7 +8388,7 @@ impl<'a, C, NC, A> FloodlightActivityMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> FloodlightActivityListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> FloodlightActivityListCall<'a, C, A> { FloodlightActivityListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -8423,7 +8419,7 @@ impl<'a, C, NC, A> FloodlightActivityMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn insert(&self, request: &FloodlightActivity, profile_id: &str) -> FloodlightActivityInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &FloodlightActivity, profile_id: &str) -> FloodlightActivityInsertCall<'a, C, A> { FloodlightActivityInsertCall { hub: self.hub, _request: request.clone(), @@ -8442,7 +8438,7 @@ impl<'a, C, NC, A> FloodlightActivityMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Floodlight activity ID. - pub fn delete(&self, profile_id: &str, id: &str) -> FloodlightActivityDeleteCall<'a, C, NC, A> { + pub fn delete(&self, profile_id: &str, id: &str) -> FloodlightActivityDeleteCall<'a, C, A> { FloodlightActivityDeleteCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -8462,7 +8458,7 @@ impl<'a, C, NC, A> FloodlightActivityMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `id` - Floodlight activity ID. - pub fn patch(&self, request: &FloodlightActivity, profile_id: &str, id: &str) -> FloodlightActivityPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &FloodlightActivity, profile_id: &str, id: &str) -> FloodlightActivityPatchCall<'a, C, A> { FloodlightActivityPatchCall { hub: self.hub, _request: request.clone(), @@ -8481,7 +8477,7 @@ impl<'a, C, NC, A> FloodlightActivityMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn generatetag(&self, profile_id: &str) -> FloodlightActivityGeneratetagCall<'a, C, NC, A> { + pub fn generatetag(&self, profile_id: &str) -> FloodlightActivityGeneratetagCall<'a, C, A> { FloodlightActivityGeneratetagCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -8500,7 +8496,7 @@ impl<'a, C, NC, A> FloodlightActivityMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn update(&self, request: &FloodlightActivity, profile_id: &str) -> FloodlightActivityUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &FloodlightActivity, profile_id: &str) -> FloodlightActivityUpdateCall<'a, C, A> { FloodlightActivityUpdateCall { hub: self.hub, _request: request.clone(), @@ -8542,15 +8538,15 @@ impl<'a, C, NC, A> FloodlightActivityMethods<'a, C, NC, A> { /// let rb = hub.regions(); /// # } /// ``` -pub struct RegionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RegionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for RegionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for RegionMethods<'a, C, A> {} -impl<'a, C, NC, A> RegionMethods<'a, C, NC, A> { +impl<'a, C, A> RegionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -8559,7 +8555,7 @@ impl<'a, C, NC, A> RegionMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> RegionListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> RegionListCall<'a, C, A> { RegionListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -8600,15 +8596,15 @@ impl<'a, C, NC, A> RegionMethods<'a, C, NC, A> { /// let rb = hub.creative_groups(); /// # } /// ``` -pub struct CreativeGroupMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeGroupMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for CreativeGroupMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CreativeGroupMethods<'a, C, A> {} -impl<'a, C, NC, A> CreativeGroupMethods<'a, C, NC, A> { +impl<'a, C, A> CreativeGroupMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -8618,7 +8614,7 @@ impl<'a, C, NC, A> CreativeGroupMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn insert(&self, request: &CreativeGroup, profile_id: &str) -> CreativeGroupInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &CreativeGroup, profile_id: &str) -> CreativeGroupInsertCall<'a, C, A> { CreativeGroupInsertCall { hub: self.hub, _request: request.clone(), @@ -8637,7 +8633,7 @@ impl<'a, C, NC, A> CreativeGroupMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Creative group ID. - pub fn get(&self, profile_id: &str, id: &str) -> CreativeGroupGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> CreativeGroupGetCall<'a, C, A> { CreativeGroupGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -8656,7 +8652,7 @@ impl<'a, C, NC, A> CreativeGroupMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn update(&self, request: &CreativeGroup, profile_id: &str) -> CreativeGroupUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &CreativeGroup, profile_id: &str) -> CreativeGroupUpdateCall<'a, C, A> { CreativeGroupUpdateCall { hub: self.hub, _request: request.clone(), @@ -8674,7 +8670,7 @@ impl<'a, C, NC, A> CreativeGroupMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> CreativeGroupListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> CreativeGroupListCall<'a, C, A> { CreativeGroupListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -8701,7 +8697,7 @@ impl<'a, C, NC, A> CreativeGroupMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `id` - Creative group ID. - pub fn patch(&self, request: &CreativeGroup, profile_id: &str, id: &str) -> CreativeGroupPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &CreativeGroup, profile_id: &str, id: &str) -> CreativeGroupPatchCall<'a, C, A> { CreativeGroupPatchCall { hub: self.hub, _request: request.clone(), @@ -8744,15 +8740,15 @@ impl<'a, C, NC, A> CreativeGroupMethods<'a, C, NC, A> { /// let rb = hub.subaccounts(); /// # } /// ``` -pub struct SubaccountMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubaccountMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for SubaccountMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for SubaccountMethods<'a, C, A> {} -impl<'a, C, NC, A> SubaccountMethods<'a, C, NC, A> { +impl<'a, C, A> SubaccountMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -8763,7 +8759,7 @@ impl<'a, C, NC, A> SubaccountMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `id` - Subaccount ID. - pub fn patch(&self, request: &Subaccount, profile_id: &str, id: &str) -> SubaccountPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Subaccount, profile_id: &str, id: &str) -> SubaccountPatchCall<'a, C, A> { SubaccountPatchCall { hub: self.hub, _request: request.clone(), @@ -8783,7 +8779,7 @@ impl<'a, C, NC, A> SubaccountMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn insert(&self, request: &Subaccount, profile_id: &str) -> SubaccountInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Subaccount, profile_id: &str) -> SubaccountInsertCall<'a, C, A> { SubaccountInsertCall { hub: self.hub, _request: request.clone(), @@ -8801,7 +8797,7 @@ impl<'a, C, NC, A> SubaccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> SubaccountListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> SubaccountListCall<'a, C, A> { SubaccountListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -8825,7 +8821,7 @@ impl<'a, C, NC, A> SubaccountMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn update(&self, request: &Subaccount, profile_id: &str) -> SubaccountUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Subaccount, profile_id: &str) -> SubaccountUpdateCall<'a, C, A> { SubaccountUpdateCall { hub: self.hub, _request: request.clone(), @@ -8844,7 +8840,7 @@ impl<'a, C, NC, A> SubaccountMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Subaccount ID. - pub fn get(&self, profile_id: &str, id: &str) -> SubaccountGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> SubaccountGetCall<'a, C, A> { SubaccountGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -8886,15 +8882,15 @@ impl<'a, C, NC, A> SubaccountMethods<'a, C, NC, A> { /// let rb = hub.mobile_carriers(); /// # } /// ``` -pub struct MobileCarrierMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MobileCarrierMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for MobileCarrierMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for MobileCarrierMethods<'a, C, A> {} -impl<'a, C, NC, A> MobileCarrierMethods<'a, C, NC, A> { +impl<'a, C, A> MobileCarrierMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -8903,7 +8899,7 @@ impl<'a, C, NC, A> MobileCarrierMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> MobileCarrierListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> MobileCarrierListCall<'a, C, A> { MobileCarrierListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -8944,15 +8940,15 @@ impl<'a, C, NC, A> MobileCarrierMethods<'a, C, NC, A> { /// let rb = hub.floodlight_configurations(); /// # } /// ``` -pub struct FloodlightConfigurationMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FloodlightConfigurationMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for FloodlightConfigurationMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for FloodlightConfigurationMethods<'a, C, A> {} -impl<'a, C, NC, A> FloodlightConfigurationMethods<'a, C, NC, A> { +impl<'a, C, A> FloodlightConfigurationMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -8962,7 +8958,7 @@ impl<'a, C, NC, A> FloodlightConfigurationMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn update(&self, request: &FloodlightConfiguration, profile_id: &str) -> FloodlightConfigurationUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &FloodlightConfiguration, profile_id: &str) -> FloodlightConfigurationUpdateCall<'a, C, A> { FloodlightConfigurationUpdateCall { hub: self.hub, _request: request.clone(), @@ -8982,7 +8978,7 @@ impl<'a, C, NC, A> FloodlightConfigurationMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `id` - Floodlight configuration ID. - pub fn patch(&self, request: &FloodlightConfiguration, profile_id: &str, id: &str) -> FloodlightConfigurationPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &FloodlightConfiguration, profile_id: &str, id: &str) -> FloodlightConfigurationPatchCall<'a, C, A> { FloodlightConfigurationPatchCall { hub: self.hub, _request: request.clone(), @@ -9002,7 +8998,7 @@ impl<'a, C, NC, A> FloodlightConfigurationMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Floodlight configuration ID. - pub fn get(&self, profile_id: &str, id: &str) -> FloodlightConfigurationGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> FloodlightConfigurationGetCall<'a, C, A> { FloodlightConfigurationGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -9020,7 +9016,7 @@ impl<'a, C, NC, A> FloodlightConfigurationMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> FloodlightConfigurationListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> FloodlightConfigurationListCall<'a, C, A> { FloodlightConfigurationListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -9062,15 +9058,15 @@ impl<'a, C, NC, A> FloodlightConfigurationMethods<'a, C, NC, A> { /// let rb = hub.operating_systems(); /// # } /// ``` -pub struct OperatingSystemMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct OperatingSystemMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for OperatingSystemMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for OperatingSystemMethods<'a, C, A> {} -impl<'a, C, NC, A> OperatingSystemMethods<'a, C, NC, A> { +impl<'a, C, A> OperatingSystemMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -9079,7 +9075,7 @@ impl<'a, C, NC, A> OperatingSystemMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> OperatingSystemListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> OperatingSystemListCall<'a, C, A> { OperatingSystemListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -9120,15 +9116,15 @@ impl<'a, C, NC, A> OperatingSystemMethods<'a, C, NC, A> { /// let rb = hub.files(); /// # } /// ``` -pub struct FileMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FileMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for FileMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for FileMethods<'a, C, A> {} -impl<'a, C, NC, A> FileMethods<'a, C, NC, A> { +impl<'a, C, A> FileMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -9137,7 +9133,7 @@ impl<'a, C, NC, A> FileMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - The DFA profile ID. - pub fn list(&self, profile_id: &str) -> FileListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> FileListCall<'a, C, A> { FileListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -9160,7 +9156,7 @@ impl<'a, C, NC, A> FileMethods<'a, C, NC, A> { /// /// * `reportId` - The ID of the report. /// * `fileId` - The ID of the report file. - pub fn get(&self, report_id: &str, file_id: &str) -> FileGetCall<'a, C, NC, A> { + pub fn get(&self, report_id: &str, file_id: &str) -> FileGetCall<'a, C, A> { FileGetCall { hub: self.hub, _report_id: report_id.to_string(), @@ -9202,15 +9198,15 @@ impl<'a, C, NC, A> FileMethods<'a, C, NC, A> { /// let rb = hub.placement_groups(); /// # } /// ``` -pub struct PlacementGroupMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlacementGroupMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for PlacementGroupMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PlacementGroupMethods<'a, C, A> {} -impl<'a, C, NC, A> PlacementGroupMethods<'a, C, NC, A> { +impl<'a, C, A> PlacementGroupMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -9219,7 +9215,7 @@ impl<'a, C, NC, A> PlacementGroupMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> PlacementGroupListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> PlacementGroupListCall<'a, C, A> { PlacementGroupListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -9252,7 +9248,7 @@ impl<'a, C, NC, A> PlacementGroupMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn update(&self, request: &PlacementGroup, profile_id: &str) -> PlacementGroupUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &PlacementGroup, profile_id: &str) -> PlacementGroupUpdateCall<'a, C, A> { PlacementGroupUpdateCall { hub: self.hub, _request: request.clone(), @@ -9271,7 +9267,7 @@ impl<'a, C, NC, A> PlacementGroupMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn insert(&self, request: &PlacementGroup, profile_id: &str) -> PlacementGroupInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &PlacementGroup, profile_id: &str) -> PlacementGroupInsertCall<'a, C, A> { PlacementGroupInsertCall { hub: self.hub, _request: request.clone(), @@ -9290,7 +9286,7 @@ impl<'a, C, NC, A> PlacementGroupMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Placement group ID. - pub fn get(&self, profile_id: &str, id: &str) -> PlacementGroupGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> PlacementGroupGetCall<'a, C, A> { PlacementGroupGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -9310,7 +9306,7 @@ impl<'a, C, NC, A> PlacementGroupMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `id` - Placement group ID. - pub fn patch(&self, request: &PlacementGroup, profile_id: &str, id: &str) -> PlacementGroupPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &PlacementGroup, profile_id: &str, id: &str) -> PlacementGroupPatchCall<'a, C, A> { PlacementGroupPatchCall { hub: self.hub, _request: request.clone(), @@ -9353,15 +9349,15 @@ impl<'a, C, NC, A> PlacementGroupMethods<'a, C, NC, A> { /// let rb = hub.creative_assets(); /// # } /// ``` -pub struct CreativeAssetMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeAssetMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for CreativeAssetMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CreativeAssetMethods<'a, C, A> {} -impl<'a, C, NC, A> CreativeAssetMethods<'a, C, NC, A> { +impl<'a, C, A> CreativeAssetMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -9372,7 +9368,7 @@ impl<'a, C, NC, A> CreativeAssetMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `advertiserId` - Advertiser ID of this creative. This is a required field. - pub fn insert(&self, request: &CreativeAssetMetadata, profile_id: &str, advertiser_id: &str) -> CreativeAssetInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &CreativeAssetMetadata, profile_id: &str, advertiser_id: &str) -> CreativeAssetInsertCall<'a, C, A> { CreativeAssetInsertCall { hub: self.hub, _request: request.clone(), @@ -9415,15 +9411,15 @@ impl<'a, C, NC, A> CreativeAssetMethods<'a, C, NC, A> { /// let rb = hub.user_role_permissions(); /// # } /// ``` -pub struct UserRolePermissionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserRolePermissionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for UserRolePermissionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for UserRolePermissionMethods<'a, C, A> {} -impl<'a, C, NC, A> UserRolePermissionMethods<'a, C, NC, A> { +impl<'a, C, A> UserRolePermissionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -9433,7 +9429,7 @@ impl<'a, C, NC, A> UserRolePermissionMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - User role permission ID. - pub fn get(&self, profile_id: &str, id: &str) -> UserRolePermissionGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> UserRolePermissionGetCall<'a, C, A> { UserRolePermissionGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -9451,7 +9447,7 @@ impl<'a, C, NC, A> UserRolePermissionMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> UserRolePermissionListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> UserRolePermissionListCall<'a, C, A> { UserRolePermissionListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -9493,15 +9489,15 @@ impl<'a, C, NC, A> UserRolePermissionMethods<'a, C, NC, A> { /// let rb = hub.account_permission_groups(); /// # } /// ``` -pub struct AccountPermissionGroupMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountPermissionGroupMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for AccountPermissionGroupMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AccountPermissionGroupMethods<'a, C, A> {} -impl<'a, C, NC, A> AccountPermissionGroupMethods<'a, C, NC, A> { +impl<'a, C, A> AccountPermissionGroupMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -9510,7 +9506,7 @@ impl<'a, C, NC, A> AccountPermissionGroupMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> AccountPermissionGroupListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> AccountPermissionGroupListCall<'a, C, A> { AccountPermissionGroupListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -9528,7 +9524,7 @@ impl<'a, C, NC, A> AccountPermissionGroupMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Account permission group ID. - pub fn get(&self, profile_id: &str, id: &str) -> AccountPermissionGroupGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> AccountPermissionGroupGetCall<'a, C, A> { AccountPermissionGroupGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -9570,15 +9566,15 @@ impl<'a, C, NC, A> AccountPermissionGroupMethods<'a, C, NC, A> { /// let rb = hub.content_categories(); /// # } /// ``` -pub struct ContentCategoryMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ContentCategoryMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for ContentCategoryMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ContentCategoryMethods<'a, C, A> {} -impl<'a, C, NC, A> ContentCategoryMethods<'a, C, NC, A> { +impl<'a, C, A> ContentCategoryMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -9587,7 +9583,7 @@ impl<'a, C, NC, A> ContentCategoryMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> ContentCategoryListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> ContentCategoryListCall<'a, C, A> { ContentCategoryListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -9611,7 +9607,7 @@ impl<'a, C, NC, A> ContentCategoryMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn update(&self, request: &ContentCategory, profile_id: &str) -> ContentCategoryUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &ContentCategory, profile_id: &str) -> ContentCategoryUpdateCall<'a, C, A> { ContentCategoryUpdateCall { hub: self.hub, _request: request.clone(), @@ -9630,7 +9626,7 @@ impl<'a, C, NC, A> ContentCategoryMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn insert(&self, request: &ContentCategory, profile_id: &str) -> ContentCategoryInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &ContentCategory, profile_id: &str) -> ContentCategoryInsertCall<'a, C, A> { ContentCategoryInsertCall { hub: self.hub, _request: request.clone(), @@ -9649,7 +9645,7 @@ impl<'a, C, NC, A> ContentCategoryMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Content category ID. - pub fn delete(&self, profile_id: &str, id: &str) -> ContentCategoryDeleteCall<'a, C, NC, A> { + pub fn delete(&self, profile_id: &str, id: &str) -> ContentCategoryDeleteCall<'a, C, A> { ContentCategoryDeleteCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -9668,7 +9664,7 @@ impl<'a, C, NC, A> ContentCategoryMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Content category ID. - pub fn get(&self, profile_id: &str, id: &str) -> ContentCategoryGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> ContentCategoryGetCall<'a, C, A> { ContentCategoryGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -9688,7 +9684,7 @@ impl<'a, C, NC, A> ContentCategoryMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `id` - Content category ID. - pub fn patch(&self, request: &ContentCategory, profile_id: &str, id: &str) -> ContentCategoryPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &ContentCategory, profile_id: &str, id: &str) -> ContentCategoryPatchCall<'a, C, A> { ContentCategoryPatchCall { hub: self.hub, _request: request.clone(), @@ -9731,15 +9727,15 @@ impl<'a, C, NC, A> ContentCategoryMethods<'a, C, NC, A> { /// let rb = hub.creatives(); /// # } /// ``` -pub struct CreativeMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for CreativeMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CreativeMethods<'a, C, A> {} -impl<'a, C, NC, A> CreativeMethods<'a, C, NC, A> { +impl<'a, C, A> CreativeMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -9749,7 +9745,7 @@ impl<'a, C, NC, A> CreativeMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn insert(&self, request: &Creative, profile_id: &str) -> CreativeInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Creative, profile_id: &str) -> CreativeInsertCall<'a, C, A> { CreativeInsertCall { hub: self.hub, _request: request.clone(), @@ -9768,7 +9764,7 @@ impl<'a, C, NC, A> CreativeMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn update(&self, request: &Creative, profile_id: &str) -> CreativeUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Creative, profile_id: &str) -> CreativeUpdateCall<'a, C, A> { CreativeUpdateCall { hub: self.hub, _request: request.clone(), @@ -9787,7 +9783,7 @@ impl<'a, C, NC, A> CreativeMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Creative ID. - pub fn get(&self, profile_id: &str, id: &str) -> CreativeGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> CreativeGetCall<'a, C, A> { CreativeGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -9805,7 +9801,7 @@ impl<'a, C, NC, A> CreativeMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> CreativeListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> CreativeListCall<'a, C, A> { CreativeListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -9840,7 +9836,7 @@ impl<'a, C, NC, A> CreativeMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `id` - Creative ID. - pub fn patch(&self, request: &Creative, profile_id: &str, id: &str) -> CreativePatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Creative, profile_id: &str, id: &str) -> CreativePatchCall<'a, C, A> { CreativePatchCall { hub: self.hub, _request: request.clone(), @@ -9883,15 +9879,15 @@ impl<'a, C, NC, A> CreativeMethods<'a, C, NC, A> { /// let rb = hub.campaigns(); /// # } /// ``` -pub struct CampaignMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CampaignMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for CampaignMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CampaignMethods<'a, C, A> {} -impl<'a, C, NC, A> CampaignMethods<'a, C, NC, A> { +impl<'a, C, A> CampaignMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -9901,7 +9897,7 @@ impl<'a, C, NC, A> CampaignMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Campaign ID. - pub fn get(&self, profile_id: &str, id: &str) -> CampaignGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> CampaignGetCall<'a, C, A> { CampaignGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -9922,7 +9918,7 @@ impl<'a, C, NC, A> CampaignMethods<'a, C, NC, A> { /// * `profileId` - User profile ID associated with this request. /// * `defaultLandingPageName` - Default landing page name for this new campaign. Must be less than 256 characters long. /// * `defaultLandingPageUrl` - Default landing page URL for this new campaign. - pub fn insert(&self, request: &Campaign, profile_id: &str, default_landing_page_name: &str, default_landing_page_url: &str) -> CampaignInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Campaign, profile_id: &str, default_landing_page_name: &str, default_landing_page_url: &str) -> CampaignInsertCall<'a, C, A> { CampaignInsertCall { hub: self.hub, _request: request.clone(), @@ -9944,7 +9940,7 @@ impl<'a, C, NC, A> CampaignMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `id` - Campaign ID. - pub fn patch(&self, request: &Campaign, profile_id: &str, id: &str) -> CampaignPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Campaign, profile_id: &str, id: &str) -> CampaignPatchCall<'a, C, A> { CampaignPatchCall { hub: self.hub, _request: request.clone(), @@ -9964,7 +9960,7 @@ impl<'a, C, NC, A> CampaignMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn update(&self, request: &Campaign, profile_id: &str) -> CampaignUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Campaign, profile_id: &str) -> CampaignUpdateCall<'a, C, A> { CampaignUpdateCall { hub: self.hub, _request: request.clone(), @@ -9982,7 +9978,7 @@ impl<'a, C, NC, A> CampaignMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> CampaignListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> CampaignListCall<'a, C, A> { CampaignListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -10036,15 +10032,15 @@ impl<'a, C, NC, A> CampaignMethods<'a, C, NC, A> { /// let rb = hub.event_tags(); /// # } /// ``` -pub struct EventTagMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventTagMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for EventTagMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for EventTagMethods<'a, C, A> {} -impl<'a, C, NC, A> EventTagMethods<'a, C, NC, A> { +impl<'a, C, A> EventTagMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -10054,7 +10050,7 @@ impl<'a, C, NC, A> EventTagMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Event tag ID. - pub fn delete(&self, profile_id: &str, id: &str) -> EventTagDeleteCall<'a, C, NC, A> { + pub fn delete(&self, profile_id: &str, id: &str) -> EventTagDeleteCall<'a, C, A> { EventTagDeleteCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -10072,7 +10068,7 @@ impl<'a, C, NC, A> EventTagMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> EventTagListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> EventTagListCall<'a, C, A> { EventTagListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -10100,7 +10096,7 @@ impl<'a, C, NC, A> EventTagMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn insert(&self, request: &EventTag, profile_id: &str) -> EventTagInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &EventTag, profile_id: &str) -> EventTagInsertCall<'a, C, A> { EventTagInsertCall { hub: self.hub, _request: request.clone(), @@ -10120,7 +10116,7 @@ impl<'a, C, NC, A> EventTagMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `id` - Event tag ID. - pub fn patch(&self, request: &EventTag, profile_id: &str, id: &str) -> EventTagPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &EventTag, profile_id: &str, id: &str) -> EventTagPatchCall<'a, C, A> { EventTagPatchCall { hub: self.hub, _request: request.clone(), @@ -10140,7 +10136,7 @@ impl<'a, C, NC, A> EventTagMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn update(&self, request: &EventTag, profile_id: &str) -> EventTagUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &EventTag, profile_id: &str) -> EventTagUpdateCall<'a, C, A> { EventTagUpdateCall { hub: self.hub, _request: request.clone(), @@ -10159,7 +10155,7 @@ impl<'a, C, NC, A> EventTagMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Event tag ID. - pub fn get(&self, profile_id: &str, id: &str) -> EventTagGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> EventTagGetCall<'a, C, A> { EventTagGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -10201,15 +10197,15 @@ impl<'a, C, NC, A> EventTagMethods<'a, C, NC, A> { /// let rb = hub.cities(); /// # } /// ``` -pub struct CityMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CityMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for CityMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CityMethods<'a, C, A> {} -impl<'a, C, NC, A> CityMethods<'a, C, NC, A> { +impl<'a, C, A> CityMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -10218,7 +10214,7 @@ impl<'a, C, NC, A> CityMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> CityListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> CityListCall<'a, C, A> { CityListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -10263,15 +10259,15 @@ impl<'a, C, NC, A> CityMethods<'a, C, NC, A> { /// let rb = hub.placement_strategies(); /// # } /// ``` -pub struct PlacementStrategyMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlacementStrategyMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for PlacementStrategyMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PlacementStrategyMethods<'a, C, A> {} -impl<'a, C, NC, A> PlacementStrategyMethods<'a, C, NC, A> { +impl<'a, C, A> PlacementStrategyMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -10280,7 +10276,7 @@ impl<'a, C, NC, A> PlacementStrategyMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> PlacementStrategyListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> PlacementStrategyListCall<'a, C, A> { PlacementStrategyListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -10304,7 +10300,7 @@ impl<'a, C, NC, A> PlacementStrategyMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn update(&self, request: &PlacementStrategy, profile_id: &str) -> PlacementStrategyUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &PlacementStrategy, profile_id: &str) -> PlacementStrategyUpdateCall<'a, C, A> { PlacementStrategyUpdateCall { hub: self.hub, _request: request.clone(), @@ -10323,7 +10319,7 @@ impl<'a, C, NC, A> PlacementStrategyMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Placement strategy ID. - pub fn get(&self, profile_id: &str, id: &str) -> PlacementStrategyGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> PlacementStrategyGetCall<'a, C, A> { PlacementStrategyGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -10342,7 +10338,7 @@ impl<'a, C, NC, A> PlacementStrategyMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Placement strategy ID. - pub fn delete(&self, profile_id: &str, id: &str) -> PlacementStrategyDeleteCall<'a, C, NC, A> { + pub fn delete(&self, profile_id: &str, id: &str) -> PlacementStrategyDeleteCall<'a, C, A> { PlacementStrategyDeleteCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -10361,7 +10357,7 @@ impl<'a, C, NC, A> PlacementStrategyMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn insert(&self, request: &PlacementStrategy, profile_id: &str) -> PlacementStrategyInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &PlacementStrategy, profile_id: &str) -> PlacementStrategyInsertCall<'a, C, A> { PlacementStrategyInsertCall { hub: self.hub, _request: request.clone(), @@ -10381,7 +10377,7 @@ impl<'a, C, NC, A> PlacementStrategyMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `id` - Placement strategy ID. - pub fn patch(&self, request: &PlacementStrategy, profile_id: &str, id: &str) -> PlacementStrategyPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &PlacementStrategy, profile_id: &str, id: &str) -> PlacementStrategyPatchCall<'a, C, A> { PlacementStrategyPatchCall { hub: self.hub, _request: request.clone(), @@ -10424,15 +10420,15 @@ impl<'a, C, NC, A> PlacementStrategyMethods<'a, C, NC, A> { /// let rb = hub.directory_sites(); /// # } /// ``` -pub struct DirectorySiteMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DirectorySiteMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for DirectorySiteMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for DirectorySiteMethods<'a, C, A> {} -impl<'a, C, NC, A> DirectorySiteMethods<'a, C, NC, A> { +impl<'a, C, A> DirectorySiteMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -10441,7 +10437,7 @@ impl<'a, C, NC, A> DirectorySiteMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> DirectorySiteListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> DirectorySiteListCall<'a, C, A> { DirectorySiteListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -10472,7 +10468,7 @@ impl<'a, C, NC, A> DirectorySiteMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Directory site ID. - pub fn get(&self, profile_id: &str, id: &str) -> DirectorySiteGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> DirectorySiteGetCall<'a, C, A> { DirectorySiteGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -10514,15 +10510,15 @@ impl<'a, C, NC, A> DirectorySiteMethods<'a, C, NC, A> { /// let rb = hub.sizes(); /// # } /// ``` -pub struct SizeMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SizeMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for SizeMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for SizeMethods<'a, C, A> {} -impl<'a, C, NC, A> SizeMethods<'a, C, NC, A> { +impl<'a, C, A> SizeMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -10532,7 +10528,7 @@ impl<'a, C, NC, A> SizeMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn insert(&self, request: &Size, profile_id: &str) -> SizeInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Size, profile_id: &str) -> SizeInsertCall<'a, C, A> { SizeInsertCall { hub: self.hub, _request: request.clone(), @@ -10550,7 +10546,7 @@ impl<'a, C, NC, A> SizeMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> SizeListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> SizeListCall<'a, C, A> { SizeListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -10572,7 +10568,7 @@ impl<'a, C, NC, A> SizeMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Size ID. - pub fn get(&self, profile_id: &str, id: &str) -> SizeGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> SizeGetCall<'a, C, A> { SizeGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -10614,15 +10610,15 @@ impl<'a, C, NC, A> SizeMethods<'a, C, NC, A> { /// let rb = hub.account_active_ad_summaries(); /// # } /// ``` -pub struct AccountActiveAdSummaryMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountActiveAdSummaryMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for AccountActiveAdSummaryMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AccountActiveAdSummaryMethods<'a, C, A> {} -impl<'a, C, NC, A> AccountActiveAdSummaryMethods<'a, C, NC, A> { +impl<'a, C, A> AccountActiveAdSummaryMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -10632,7 +10628,7 @@ impl<'a, C, NC, A> AccountActiveAdSummaryMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `summaryAccountId` - Account ID. - pub fn get(&self, profile_id: &str, summary_account_id: &str) -> AccountActiveAdSummaryGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, summary_account_id: &str) -> AccountActiveAdSummaryGetCall<'a, C, A> { AccountActiveAdSummaryGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -10674,15 +10670,15 @@ impl<'a, C, NC, A> AccountActiveAdSummaryMethods<'a, C, NC, A> { /// let rb = hub.account_user_profiles(); /// # } /// ``` -pub struct AccountUserProfileMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountUserProfileMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for AccountUserProfileMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AccountUserProfileMethods<'a, C, A> {} -impl<'a, C, NC, A> AccountUserProfileMethods<'a, C, NC, A> { +impl<'a, C, A> AccountUserProfileMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -10692,7 +10688,7 @@ impl<'a, C, NC, A> AccountUserProfileMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn update(&self, request: &AccountUserProfile, profile_id: &str) -> AccountUserProfileUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &AccountUserProfile, profile_id: &str) -> AccountUserProfileUpdateCall<'a, C, A> { AccountUserProfileUpdateCall { hub: self.hub, _request: request.clone(), @@ -10710,7 +10706,7 @@ impl<'a, C, NC, A> AccountUserProfileMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> AccountUserProfileListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> AccountUserProfileListCall<'a, C, A> { AccountUserProfileListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -10738,7 +10734,7 @@ impl<'a, C, NC, A> AccountUserProfileMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `id` - User profile ID. - pub fn patch(&self, request: &AccountUserProfile, profile_id: &str, id: &str) -> AccountUserProfilePatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &AccountUserProfile, profile_id: &str, id: &str) -> AccountUserProfilePatchCall<'a, C, A> { AccountUserProfilePatchCall { hub: self.hub, _request: request.clone(), @@ -10758,7 +10754,7 @@ impl<'a, C, NC, A> AccountUserProfileMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - User profile ID. - pub fn get(&self, profile_id: &str, id: &str) -> AccountUserProfileGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> AccountUserProfileGetCall<'a, C, A> { AccountUserProfileGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -10800,15 +10796,15 @@ impl<'a, C, NC, A> AccountUserProfileMethods<'a, C, NC, A> { /// let rb = hub.countries(); /// # } /// ``` -pub struct CountryMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CountryMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for CountryMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CountryMethods<'a, C, A> {} -impl<'a, C, NC, A> CountryMethods<'a, C, NC, A> { +impl<'a, C, A> CountryMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -10817,7 +10813,7 @@ impl<'a, C, NC, A> CountryMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> CountryListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> CountryListCall<'a, C, A> { CountryListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -10835,7 +10831,7 @@ impl<'a, C, NC, A> CountryMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `dartId` - Country DART ID. - pub fn get(&self, profile_id: &str, dart_id: &str) -> CountryGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, dart_id: &str) -> CountryGetCall<'a, C, A> { CountryGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -10877,15 +10873,15 @@ impl<'a, C, NC, A> CountryMethods<'a, C, NC, A> { /// let rb = hub.creative_field_values(); /// # } /// ``` -pub struct CreativeFieldValueMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeFieldValueMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for CreativeFieldValueMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CreativeFieldValueMethods<'a, C, A> {} -impl<'a, C, NC, A> CreativeFieldValueMethods<'a, C, NC, A> { +impl<'a, C, A> CreativeFieldValueMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -10897,7 +10893,7 @@ impl<'a, C, NC, A> CreativeFieldValueMethods<'a, C, NC, A> { /// * `profileId` - User profile ID associated with this request. /// * `creativeFieldId` - Creative field ID for this creative field value. /// * `id` - Creative Field Value ID - pub fn patch(&self, request: &CreativeFieldValue, profile_id: &str, creative_field_id: &str, id: &str) -> CreativeFieldValuePatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &CreativeFieldValue, profile_id: &str, creative_field_id: &str, id: &str) -> CreativeFieldValuePatchCall<'a, C, A> { CreativeFieldValuePatchCall { hub: self.hub, _request: request.clone(), @@ -10919,7 +10915,7 @@ impl<'a, C, NC, A> CreativeFieldValueMethods<'a, C, NC, A> { /// * `profileId` - User profile ID associated with this request. /// * `creativeFieldId` - Creative field ID for this creative field value. /// * `id` - Creative Field Value ID - pub fn delete(&self, profile_id: &str, creative_field_id: &str, id: &str) -> CreativeFieldValueDeleteCall<'a, C, NC, A> { + pub fn delete(&self, profile_id: &str, creative_field_id: &str, id: &str) -> CreativeFieldValueDeleteCall<'a, C, A> { CreativeFieldValueDeleteCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -10940,7 +10936,7 @@ impl<'a, C, NC, A> CreativeFieldValueMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `creativeFieldId` - Creative field ID for this creative field value. - pub fn insert(&self, request: &CreativeFieldValue, profile_id: &str, creative_field_id: &str) -> CreativeFieldValueInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &CreativeFieldValue, profile_id: &str, creative_field_id: &str) -> CreativeFieldValueInsertCall<'a, C, A> { CreativeFieldValueInsertCall { hub: self.hub, _request: request.clone(), @@ -10961,7 +10957,7 @@ impl<'a, C, NC, A> CreativeFieldValueMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `creativeFieldId` - Creative field ID for this creative field value. - pub fn update(&self, request: &CreativeFieldValue, profile_id: &str, creative_field_id: &str) -> CreativeFieldValueUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &CreativeFieldValue, profile_id: &str, creative_field_id: &str) -> CreativeFieldValueUpdateCall<'a, C, A> { CreativeFieldValueUpdateCall { hub: self.hub, _request: request.clone(), @@ -10982,7 +10978,7 @@ impl<'a, C, NC, A> CreativeFieldValueMethods<'a, C, NC, A> { /// * `profileId` - User profile ID associated with this request. /// * `creativeFieldId` - Creative field ID for this creative field value. /// * `id` - Creative Field Value ID - pub fn get(&self, profile_id: &str, creative_field_id: &str, id: &str) -> CreativeFieldValueGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, creative_field_id: &str, id: &str) -> CreativeFieldValueGetCall<'a, C, A> { CreativeFieldValueGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -11002,7 +10998,7 @@ impl<'a, C, NC, A> CreativeFieldValueMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `creativeFieldId` - Creative field ID for this creative field value. - pub fn list(&self, profile_id: &str, creative_field_id: &str) -> CreativeFieldValueListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str, creative_field_id: &str) -> CreativeFieldValueListCall<'a, C, A> { CreativeFieldValueListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -11050,15 +11046,15 @@ impl<'a, C, NC, A> CreativeFieldValueMethods<'a, C, NC, A> { /// let rb = hub.reports(); /// # } /// ``` -pub struct ReportMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for ReportMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ReportMethods<'a, C, A> {} -impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { +impl<'a, C, A> ReportMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -11069,7 +11065,7 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - The DFA user profile ID. /// * `reportId` - The ID of the report. - pub fn update(&self, request: &Report, profile_id: &str, report_id: &str) -> ReportUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Report, profile_id: &str, report_id: &str) -> ReportUpdateCall<'a, C, A> { ReportUpdateCall { hub: self.hub, _request: request.clone(), @@ -11089,7 +11085,7 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// /// * `profileId` - The DFA profile ID. /// * `reportId` - The ID of the report. - pub fn run(&self, profile_id: &str, report_id: &str) -> ReportRunCall<'a, C, NC, A> { + pub fn run(&self, profile_id: &str, report_id: &str) -> ReportRunCall<'a, C, A> { ReportRunCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -11110,7 +11106,7 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - The DFA user profile ID. /// * `reportId` - The ID of the report. - pub fn patch(&self, request: &Report, profile_id: &str, report_id: &str) -> ReportPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Report, profile_id: &str, report_id: &str) -> ReportPatchCall<'a, C, A> { ReportPatchCall { hub: self.hub, _request: request.clone(), @@ -11130,7 +11126,7 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// /// * `profileId` - The DFA profile ID. /// * `reportId` - The ID of the parent report. - pub fn files_list(&self, profile_id: &str, report_id: &str) -> ReportFileListCall<'a, C, NC, A> { + pub fn files_list(&self, profile_id: &str, report_id: &str) -> ReportFileListCall<'a, C, A> { ReportFileListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -11153,7 +11149,7 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - The DFA user profile ID. - pub fn insert(&self, request: &Report, profile_id: &str) -> ReportInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Report, profile_id: &str) -> ReportInsertCall<'a, C, A> { ReportInsertCall { hub: self.hub, _request: request.clone(), @@ -11172,7 +11168,7 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - The DFA user profile ID. - pub fn compatible_fields_query(&self, request: &Report, profile_id: &str) -> ReportCompatibleFieldQueryCall<'a, C, NC, A> { + pub fn compatible_fields_query(&self, request: &Report, profile_id: &str) -> ReportCompatibleFieldQueryCall<'a, C, A> { ReportCompatibleFieldQueryCall { hub: self.hub, _request: request.clone(), @@ -11191,7 +11187,7 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// /// * `profileId` - The DFA user profile ID. /// * `reportId` - The ID of the report. - pub fn get(&self, profile_id: &str, report_id: &str) -> ReportGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, report_id: &str) -> ReportGetCall<'a, C, A> { ReportGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -11211,7 +11207,7 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// * `profileId` - The DFA profile ID. /// * `reportId` - The ID of the report. /// * `fileId` - The ID of the report file. - pub fn files_get(&self, profile_id: &str, report_id: &str, file_id: &str) -> ReportFileGetCall<'a, C, NC, A> { + pub fn files_get(&self, profile_id: &str, report_id: &str, file_id: &str) -> ReportFileGetCall<'a, C, A> { ReportFileGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -11231,7 +11227,7 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// /// * `profileId` - The DFA user profile ID. /// * `reportId` - The ID of the report. - pub fn delete(&self, profile_id: &str, report_id: &str) -> ReportDeleteCall<'a, C, NC, A> { + pub fn delete(&self, profile_id: &str, report_id: &str) -> ReportDeleteCall<'a, C, A> { ReportDeleteCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -11249,7 +11245,7 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - The DFA user profile ID. - pub fn list(&self, profile_id: &str) -> ReportListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> ReportListCall<'a, C, A> { ReportListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -11295,15 +11291,15 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// let rb = hub.browsers(); /// # } /// ``` -pub struct BrowserMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BrowserMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for BrowserMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for BrowserMethods<'a, C, A> {} -impl<'a, C, NC, A> BrowserMethods<'a, C, NC, A> { +impl<'a, C, A> BrowserMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -11312,7 +11308,7 @@ impl<'a, C, NC, A> BrowserMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> BrowserListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> BrowserListCall<'a, C, A> { BrowserListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -11353,15 +11349,15 @@ impl<'a, C, NC, A> BrowserMethods<'a, C, NC, A> { /// let rb = hub.placements(); /// # } /// ``` -pub struct PlacementMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlacementMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, } -impl<'a, C, NC, A> MethodsBuilder for PlacementMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PlacementMethods<'a, C, A> {} -impl<'a, C, NC, A> PlacementMethods<'a, C, NC, A> { +impl<'a, C, A> PlacementMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -11372,7 +11368,7 @@ impl<'a, C, NC, A> PlacementMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. /// * `id` - Placement ID. - pub fn patch(&self, request: &Placement, profile_id: &str, id: &str) -> PlacementPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Placement, profile_id: &str, id: &str) -> PlacementPatchCall<'a, C, A> { PlacementPatchCall { hub: self.hub, _request: request.clone(), @@ -11391,7 +11387,7 @@ impl<'a, C, NC, A> PlacementMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn list(&self, profile_id: &str) -> PlacementListCall<'a, C, NC, A> { + pub fn list(&self, profile_id: &str) -> PlacementListCall<'a, C, A> { PlacementListCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -11427,7 +11423,7 @@ impl<'a, C, NC, A> PlacementMethods<'a, C, NC, A> { /// /// * `profileId` - User profile ID associated with this request. /// * `id` - Placement ID. - pub fn get(&self, profile_id: &str, id: &str) -> PlacementGetCall<'a, C, NC, A> { + pub fn get(&self, profile_id: &str, id: &str) -> PlacementGetCall<'a, C, A> { PlacementGetCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -11446,7 +11442,7 @@ impl<'a, C, NC, A> PlacementMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn insert(&self, request: &Placement, profile_id: &str) -> PlacementInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Placement, profile_id: &str) -> PlacementInsertCall<'a, C, A> { PlacementInsertCall { hub: self.hub, _request: request.clone(), @@ -11465,7 +11461,7 @@ impl<'a, C, NC, A> PlacementMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `profileId` - User profile ID associated with this request. - pub fn update(&self, request: &Placement, profile_id: &str) -> PlacementUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Placement, profile_id: &str) -> PlacementUpdateCall<'a, C, A> { PlacementUpdateCall { hub: self.hub, _request: request.clone(), @@ -11483,7 +11479,7 @@ impl<'a, C, NC, A> PlacementMethods<'a, C, NC, A> { /// # Arguments /// /// * `profileId` - User profile ID associated with this request. - pub fn generatetags(&self, profile_id: &str) -> PlacementGeneratetagCall<'a, C, NC, A> { + pub fn generatetags(&self, profile_id: &str) -> PlacementGeneratetagCall<'a, C, A> { PlacementGeneratetagCall { hub: self.hub, _profile_id: profile_id.to_string(), @@ -11535,10 +11531,10 @@ impl<'a, C, NC, A> PlacementMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct UserRolePermissionGroupGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserRolePermissionGroupGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -11546,9 +11542,9 @@ pub struct UserRolePermissionGroupGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserRolePermissionGroupGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserRolePermissionGroupGetCall<'a, C, A> {} -impl<'a, C, NC, A> UserRolePermissionGroupGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserRolePermissionGroupGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11681,7 +11677,7 @@ impl<'a, C, NC, A> UserRolePermissionGroupGetCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> UserRolePermissionGroupGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> UserRolePermissionGroupGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -11691,7 +11687,7 @@ impl<'a, C, NC, A> UserRolePermissionGroupGetCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// User role permission group ID. - pub fn id(mut self, new_value: &str) -> UserRolePermissionGroupGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> UserRolePermissionGroupGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -11702,7 +11698,7 @@ impl<'a, C, NC, A> UserRolePermissionGroupGetCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserRolePermissionGroupGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserRolePermissionGroupGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11723,7 +11719,7 @@ impl<'a, C, NC, A> UserRolePermissionGroupGetCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserRolePermissionGroupGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserRolePermissionGroupGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11740,7 +11736,7 @@ impl<'a, C, NC, A> UserRolePermissionGroupGetCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserRolePermissionGroupGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserRolePermissionGroupGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11778,19 +11774,19 @@ impl<'a, C, NC, A> UserRolePermissionGroupGetCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct UserRolePermissionGroupListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserRolePermissionGroupListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserRolePermissionGroupListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserRolePermissionGroupListCall<'a, C, A> {} -impl<'a, C, NC, A> UserRolePermissionGroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserRolePermissionGroupListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11922,7 +11918,7 @@ impl<'a, C, NC, A> UserRolePermissionGroupListCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> UserRolePermissionGroupListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> UserRolePermissionGroupListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -11933,7 +11929,7 @@ impl<'a, C, NC, A> UserRolePermissionGroupListCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserRolePermissionGroupListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserRolePermissionGroupListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11954,7 +11950,7 @@ impl<'a, C, NC, A> UserRolePermissionGroupListCall<'a, C, NC, A> where NC: hyper /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserRolePermissionGroupListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserRolePermissionGroupListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11971,7 +11967,7 @@ impl<'a, C, NC, A> UserRolePermissionGroupListCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserRolePermissionGroupListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserRolePermissionGroupListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12009,19 +12005,19 @@ impl<'a, C, NC, A> UserRolePermissionGroupListCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct PlatformTypeListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlatformTypeListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlatformTypeListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlatformTypeListCall<'a, C, A> {} -impl<'a, C, NC, A> PlatformTypeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlatformTypeListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12153,7 +12149,7 @@ impl<'a, C, NC, A> PlatformTypeListCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> PlatformTypeListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> PlatformTypeListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -12164,7 +12160,7 @@ impl<'a, C, NC, A> PlatformTypeListCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlatformTypeListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlatformTypeListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12185,7 +12181,7 @@ impl<'a, C, NC, A> PlatformTypeListCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlatformTypeListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlatformTypeListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12202,7 +12198,7 @@ impl<'a, C, NC, A> PlatformTypeListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlatformTypeListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlatformTypeListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12246,10 +12242,10 @@ impl<'a, C, NC, A> PlatformTypeListCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct CreativeFieldUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeFieldUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: CreativeField, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -12257,9 +12253,9 @@ pub struct CreativeFieldUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeFieldUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeFieldUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeFieldUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeFieldUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12398,7 +12394,7 @@ impl<'a, C, NC, A> CreativeFieldUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CreativeField) -> CreativeFieldUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CreativeField) -> CreativeFieldUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -12408,7 +12404,7 @@ impl<'a, C, NC, A> CreativeFieldUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CreativeFieldUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CreativeFieldUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -12419,7 +12415,7 @@ impl<'a, C, NC, A> CreativeFieldUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12440,7 +12436,7 @@ impl<'a, C, NC, A> CreativeFieldUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeFieldUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeFieldUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12457,7 +12453,7 @@ impl<'a, C, NC, A> CreativeFieldUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeFieldUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeFieldUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12502,10 +12498,10 @@ impl<'a, C, NC, A> CreativeFieldUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct CreativeFieldListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeFieldListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _sort_order: Option, _sort_field: Option, @@ -12519,9 +12515,9 @@ pub struct CreativeFieldListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeFieldListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeFieldListCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeFieldListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeFieldListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12682,7 +12678,7 @@ impl<'a, C, NC, A> CreativeFieldListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CreativeFieldListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CreativeFieldListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -12690,7 +12686,7 @@ impl<'a, C, NC, A> CreativeFieldListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Order of sorted results, default is ASCENDING. - pub fn sort_order(mut self, new_value: &str) -> CreativeFieldListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> CreativeFieldListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -12698,7 +12694,7 @@ impl<'a, C, NC, A> CreativeFieldListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> CreativeFieldListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> CreativeFieldListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -12706,7 +12702,7 @@ impl<'a, C, NC, A> CreativeFieldListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Allows searching for creative fields by name or ID. Wildcards (*) are allowed. For example, "creativefield*2015" will return creative fields with names like "creativefield June 2015", "creativefield April 2015", or simply "creativefield 2015". Most of the searches also add wild-cards implicitly at the start and the end of the search string. For example, a search string of "creativefield" will match creative fields with the name "my creativefield", "creativefield 2015", or simply "creativefield". - pub fn search_string(mut self, new_value: &str) -> CreativeFieldListCall<'a, C, NC, A> { + pub fn search_string(mut self, new_value: &str) -> CreativeFieldListCall<'a, C, A> { self._search_string = Some(new_value.to_string()); self } @@ -12714,7 +12710,7 @@ impl<'a, C, NC, A> CreativeFieldListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Value of the nextPageToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> CreativeFieldListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> CreativeFieldListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -12722,7 +12718,7 @@ impl<'a, C, NC, A> CreativeFieldListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> CreativeFieldListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> CreativeFieldListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -12731,7 +12727,7 @@ impl<'a, C, NC, A> CreativeFieldListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Select only creative fields with these IDs. - pub fn add_ids(mut self, new_value: &str) -> CreativeFieldListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> CreativeFieldListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -12740,7 +12736,7 @@ impl<'a, C, NC, A> CreativeFieldListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Select only creative fields that belong to these advertisers. - pub fn add_advertiser_ids(mut self, new_value: &str) -> CreativeFieldListCall<'a, C, NC, A> { + pub fn add_advertiser_ids(mut self, new_value: &str) -> CreativeFieldListCall<'a, C, A> { self._advertiser_ids.push(new_value.to_string()); self } @@ -12751,7 +12747,7 @@ impl<'a, C, NC, A> CreativeFieldListCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12772,7 +12768,7 @@ impl<'a, C, NC, A> CreativeFieldListCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeFieldListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeFieldListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12789,7 +12785,7 @@ impl<'a, C, NC, A> CreativeFieldListCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeFieldListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeFieldListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12827,10 +12823,10 @@ impl<'a, C, NC, A> CreativeFieldListCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct CreativeFieldDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeFieldDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -12838,9 +12834,9 @@ pub struct CreativeFieldDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeFieldDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeFieldDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeFieldDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeFieldDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12962,7 +12958,7 @@ impl<'a, C, NC, A> CreativeFieldDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CreativeFieldDeleteCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CreativeFieldDeleteCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -12972,7 +12968,7 @@ impl<'a, C, NC, A> CreativeFieldDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Creative Field ID - pub fn id(mut self, new_value: &str) -> CreativeFieldDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> CreativeFieldDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -12983,7 +12979,7 @@ impl<'a, C, NC, A> CreativeFieldDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13004,7 +13000,7 @@ impl<'a, C, NC, A> CreativeFieldDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeFieldDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeFieldDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13021,7 +13017,7 @@ impl<'a, C, NC, A> CreativeFieldDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeFieldDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeFieldDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13059,10 +13055,10 @@ impl<'a, C, NC, A> CreativeFieldDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct CreativeFieldGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeFieldGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -13070,9 +13066,9 @@ pub struct CreativeFieldGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeFieldGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeFieldGetCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeFieldGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeFieldGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13205,7 +13201,7 @@ impl<'a, C, NC, A> CreativeFieldGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CreativeFieldGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CreativeFieldGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -13215,7 +13211,7 @@ impl<'a, C, NC, A> CreativeFieldGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Creative Field ID - pub fn id(mut self, new_value: &str) -> CreativeFieldGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> CreativeFieldGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -13226,7 +13222,7 @@ impl<'a, C, NC, A> CreativeFieldGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13247,7 +13243,7 @@ impl<'a, C, NC, A> CreativeFieldGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeFieldGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeFieldGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13264,7 +13260,7 @@ impl<'a, C, NC, A> CreativeFieldGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeFieldGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeFieldGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13308,10 +13304,10 @@ impl<'a, C, NC, A> CreativeFieldGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct CreativeFieldInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeFieldInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: CreativeField, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -13319,9 +13315,9 @@ pub struct CreativeFieldInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeFieldInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeFieldInsertCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeFieldInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeFieldInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13460,7 +13456,7 @@ impl<'a, C, NC, A> CreativeFieldInsertCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CreativeField) -> CreativeFieldInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CreativeField) -> CreativeFieldInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13470,7 +13466,7 @@ impl<'a, C, NC, A> CreativeFieldInsertCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CreativeFieldInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CreativeFieldInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -13481,7 +13477,7 @@ impl<'a, C, NC, A> CreativeFieldInsertCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13502,7 +13498,7 @@ impl<'a, C, NC, A> CreativeFieldInsertCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeFieldInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeFieldInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13519,7 +13515,7 @@ impl<'a, C, NC, A> CreativeFieldInsertCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeFieldInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeFieldInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13563,10 +13559,10 @@ impl<'a, C, NC, A> CreativeFieldInsertCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct CreativeFieldPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeFieldPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: CreativeField, _profile_id: String, _id: String, @@ -13575,9 +13571,9 @@ pub struct CreativeFieldPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeFieldPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeFieldPatchCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeFieldPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeFieldPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13717,7 +13713,7 @@ impl<'a, C, NC, A> CreativeFieldPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CreativeField) -> CreativeFieldPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CreativeField) -> CreativeFieldPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13727,7 +13723,7 @@ impl<'a, C, NC, A> CreativeFieldPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CreativeFieldPatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CreativeFieldPatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -13737,7 +13733,7 @@ impl<'a, C, NC, A> CreativeFieldPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Creative Field ID - pub fn id(mut self, new_value: &str) -> CreativeFieldPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> CreativeFieldPatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -13748,7 +13744,7 @@ impl<'a, C, NC, A> CreativeFieldPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13769,7 +13765,7 @@ impl<'a, C, NC, A> CreativeFieldPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeFieldPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeFieldPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13786,7 +13782,7 @@ impl<'a, C, NC, A> CreativeFieldPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeFieldPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeFieldPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13830,10 +13826,10 @@ impl<'a, C, NC, A> CreativeFieldPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct UserRoleInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserRoleInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: UserRole, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -13841,9 +13837,9 @@ pub struct UserRoleInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserRoleInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserRoleInsertCall<'a, C, A> {} -impl<'a, C, NC, A> UserRoleInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserRoleInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13982,7 +13978,7 @@ impl<'a, C, NC, A> UserRoleInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &UserRole) -> UserRoleInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &UserRole) -> UserRoleInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13992,7 +13988,7 @@ impl<'a, C, NC, A> UserRoleInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> UserRoleInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> UserRoleInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -14003,7 +13999,7 @@ impl<'a, C, NC, A> UserRoleInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserRoleInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserRoleInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14024,7 +14020,7 @@ impl<'a, C, NC, A> UserRoleInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserRoleInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserRoleInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14041,7 +14037,7 @@ impl<'a, C, NC, A> UserRoleInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserRoleInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserRoleInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14079,10 +14075,10 @@ impl<'a, C, NC, A> UserRoleInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct UserRoleGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserRoleGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -14090,9 +14086,9 @@ pub struct UserRoleGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserRoleGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserRoleGetCall<'a, C, A> {} -impl<'a, C, NC, A> UserRoleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserRoleGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14225,7 +14221,7 @@ impl<'a, C, NC, A> UserRoleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> UserRoleGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> UserRoleGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -14235,7 +14231,7 @@ impl<'a, C, NC, A> UserRoleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// User role ID. - pub fn id(mut self, new_value: &str) -> UserRoleGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> UserRoleGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -14246,7 +14242,7 @@ impl<'a, C, NC, A> UserRoleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserRoleGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserRoleGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14267,7 +14263,7 @@ impl<'a, C, NC, A> UserRoleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserRoleGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserRoleGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14284,7 +14280,7 @@ impl<'a, C, NC, A> UserRoleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserRoleGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserRoleGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14328,10 +14324,10 @@ impl<'a, C, NC, A> UserRoleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct UserRoleUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserRoleUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: UserRole, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -14339,9 +14335,9 @@ pub struct UserRoleUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserRoleUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserRoleUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> UserRoleUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserRoleUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14480,7 +14476,7 @@ impl<'a, C, NC, A> UserRoleUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &UserRole) -> UserRoleUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &UserRole) -> UserRoleUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -14490,7 +14486,7 @@ impl<'a, C, NC, A> UserRoleUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> UserRoleUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> UserRoleUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -14501,7 +14497,7 @@ impl<'a, C, NC, A> UserRoleUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserRoleUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserRoleUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14522,7 +14518,7 @@ impl<'a, C, NC, A> UserRoleUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserRoleUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserRoleUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14539,7 +14535,7 @@ impl<'a, C, NC, A> UserRoleUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserRoleUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserRoleUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14577,10 +14573,10 @@ impl<'a, C, NC, A> UserRoleUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct UserRoleDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserRoleDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -14588,9 +14584,9 @@ pub struct UserRoleDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserRoleDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserRoleDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> UserRoleDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserRoleDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14712,7 +14708,7 @@ impl<'a, C, NC, A> UserRoleDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> UserRoleDeleteCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> UserRoleDeleteCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -14722,7 +14718,7 @@ impl<'a, C, NC, A> UserRoleDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// User role ID. - pub fn id(mut self, new_value: &str) -> UserRoleDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> UserRoleDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -14733,7 +14729,7 @@ impl<'a, C, NC, A> UserRoleDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserRoleDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserRoleDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14754,7 +14750,7 @@ impl<'a, C, NC, A> UserRoleDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserRoleDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserRoleDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14771,7 +14767,7 @@ impl<'a, C, NC, A> UserRoleDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserRoleDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserRoleDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14815,10 +14811,10 @@ impl<'a, C, NC, A> UserRoleDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct UserRolePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserRolePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: UserRole, _profile_id: String, _id: String, @@ -14827,9 +14823,9 @@ pub struct UserRolePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserRolePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserRolePatchCall<'a, C, A> {} -impl<'a, C, NC, A> UserRolePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserRolePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14969,7 +14965,7 @@ impl<'a, C, NC, A> UserRolePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &UserRole) -> UserRolePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &UserRole) -> UserRolePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -14979,7 +14975,7 @@ impl<'a, C, NC, A> UserRolePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> UserRolePatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> UserRolePatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -14989,7 +14985,7 @@ impl<'a, C, NC, A> UserRolePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// User role ID. - pub fn id(mut self, new_value: &str) -> UserRolePatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> UserRolePatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -15000,7 +14996,7 @@ impl<'a, C, NC, A> UserRolePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserRolePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserRolePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15021,7 +15017,7 @@ impl<'a, C, NC, A> UserRolePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserRolePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserRolePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15038,7 +15034,7 @@ impl<'a, C, NC, A> UserRolePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserRolePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserRolePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15084,10 +15080,10 @@ impl<'a, C, NC, A> UserRolePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct UserRoleListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserRoleListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _subaccount_id: Option, _sort_order: Option, @@ -15102,9 +15098,9 @@ pub struct UserRoleListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserRoleListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserRoleListCall<'a, C, A> {} -impl<'a, C, NC, A> UserRoleListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserRoleListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15264,7 +15260,7 @@ impl<'a, C, NC, A> UserRoleListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> UserRoleListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> UserRoleListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -15272,7 +15268,7 @@ impl<'a, C, NC, A> UserRoleListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only user roles that belong to this subaccount. - pub fn subaccount_id(mut self, new_value: &str) -> UserRoleListCall<'a, C, NC, A> { + pub fn subaccount_id(mut self, new_value: &str) -> UserRoleListCall<'a, C, A> { self._subaccount_id = Some(new_value.to_string()); self } @@ -15280,7 +15276,7 @@ impl<'a, C, NC, A> UserRoleListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Order of sorted results, default is ASCENDING. - pub fn sort_order(mut self, new_value: &str) -> UserRoleListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> UserRoleListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -15288,7 +15284,7 @@ impl<'a, C, NC, A> UserRoleListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> UserRoleListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> UserRoleListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -15296,7 +15292,7 @@ impl<'a, C, NC, A> UserRoleListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Allows searching for objects by name or ID. Wildcards (*) are allowed. For example, "userrole*2015" will return objects with names like "userrole June 2015", "userrole April 2015", or simply "userrole 2015". Most of the searches also add wildcards implicitly at the start and the end of the search string. For example, a search string of "userrole" will match objects with name "my userrole", "userrole 2015", or simply "userrole". - pub fn search_string(mut self, new_value: &str) -> UserRoleListCall<'a, C, NC, A> { + pub fn search_string(mut self, new_value: &str) -> UserRoleListCall<'a, C, A> { self._search_string = Some(new_value.to_string()); self } @@ -15304,7 +15300,7 @@ impl<'a, C, NC, A> UserRoleListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Value of the nextPageToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> UserRoleListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> UserRoleListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -15312,7 +15308,7 @@ impl<'a, C, NC, A> UserRoleListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> UserRoleListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> UserRoleListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -15321,7 +15317,7 @@ impl<'a, C, NC, A> UserRoleListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only user roles with the specified IDs. - pub fn add_ids(mut self, new_value: &str) -> UserRoleListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> UserRoleListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -15329,7 +15325,7 @@ impl<'a, C, NC, A> UserRoleListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only account level user roles not associated with any specific subaccount. - pub fn account_user_role_only(mut self, new_value: bool) -> UserRoleListCall<'a, C, NC, A> { + pub fn account_user_role_only(mut self, new_value: bool) -> UserRoleListCall<'a, C, A> { self._account_user_role_only = Some(new_value); self } @@ -15340,7 +15336,7 @@ impl<'a, C, NC, A> UserRoleListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserRoleListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserRoleListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15361,7 +15357,7 @@ impl<'a, C, NC, A> UserRoleListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserRoleListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserRoleListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15378,7 +15374,7 @@ impl<'a, C, NC, A> UserRoleListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserRoleListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserRoleListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15416,19 +15412,19 @@ impl<'a, C, NC, A> UserRoleListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct OperatingSystemVersionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct OperatingSystemVersionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for OperatingSystemVersionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for OperatingSystemVersionListCall<'a, C, A> {} -impl<'a, C, NC, A> OperatingSystemVersionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> OperatingSystemVersionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15560,7 +15556,7 @@ impl<'a, C, NC, A> OperatingSystemVersionListCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> OperatingSystemVersionListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> OperatingSystemVersionListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -15571,7 +15567,7 @@ impl<'a, C, NC, A> OperatingSystemVersionListCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> OperatingSystemVersionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> OperatingSystemVersionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15592,7 +15588,7 @@ impl<'a, C, NC, A> OperatingSystemVersionListCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> OperatingSystemVersionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> OperatingSystemVersionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15609,7 +15605,7 @@ impl<'a, C, NC, A> OperatingSystemVersionListCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> OperatingSystemVersionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> OperatingSystemVersionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15647,10 +15643,10 @@ impl<'a, C, NC, A> OperatingSystemVersionListCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct LandingPageGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LandingPageGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _campaign_id: String, _id: String, @@ -15659,9 +15655,9 @@ pub struct LandingPageGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LandingPageGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LandingPageGetCall<'a, C, A> {} -impl<'a, C, NC, A> LandingPageGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LandingPageGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15795,7 +15791,7 @@ impl<'a, C, NC, A> LandingPageGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> LandingPageGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> LandingPageGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -15805,7 +15801,7 @@ impl<'a, C, NC, A> LandingPageGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Landing page campaign ID. - pub fn campaign_id(mut self, new_value: &str) -> LandingPageGetCall<'a, C, NC, A> { + pub fn campaign_id(mut self, new_value: &str) -> LandingPageGetCall<'a, C, A> { self._campaign_id = new_value.to_string(); self } @@ -15815,7 +15811,7 @@ impl<'a, C, NC, A> LandingPageGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Landing page ID. - pub fn id(mut self, new_value: &str) -> LandingPageGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> LandingPageGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -15826,7 +15822,7 @@ impl<'a, C, NC, A> LandingPageGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LandingPageGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LandingPageGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15847,7 +15843,7 @@ impl<'a, C, NC, A> LandingPageGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LandingPageGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LandingPageGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15864,7 +15860,7 @@ impl<'a, C, NC, A> LandingPageGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LandingPageGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LandingPageGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15908,10 +15904,10 @@ impl<'a, C, NC, A> LandingPageGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct LandingPageUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LandingPageUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: LandingPage, _profile_id: String, _campaign_id: String, @@ -15920,9 +15916,9 @@ pub struct LandingPageUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LandingPageUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LandingPageUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> LandingPageUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LandingPageUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16062,7 +16058,7 @@ impl<'a, C, NC, A> LandingPageUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &LandingPage) -> LandingPageUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &LandingPage) -> LandingPageUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -16072,7 +16068,7 @@ impl<'a, C, NC, A> LandingPageUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> LandingPageUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> LandingPageUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -16082,7 +16078,7 @@ impl<'a, C, NC, A> LandingPageUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Landing page campaign ID. - pub fn campaign_id(mut self, new_value: &str) -> LandingPageUpdateCall<'a, C, NC, A> { + pub fn campaign_id(mut self, new_value: &str) -> LandingPageUpdateCall<'a, C, A> { self._campaign_id = new_value.to_string(); self } @@ -16093,7 +16089,7 @@ impl<'a, C, NC, A> LandingPageUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LandingPageUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LandingPageUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16114,7 +16110,7 @@ impl<'a, C, NC, A> LandingPageUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LandingPageUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LandingPageUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16131,7 +16127,7 @@ impl<'a, C, NC, A> LandingPageUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LandingPageUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LandingPageUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16169,10 +16165,10 @@ impl<'a, C, NC, A> LandingPageUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct LandingPageListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LandingPageListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _campaign_id: String, _delegate: Option<&'a mut Delegate>, @@ -16180,9 +16176,9 @@ pub struct LandingPageListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LandingPageListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LandingPageListCall<'a, C, A> {} -impl<'a, C, NC, A> LandingPageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LandingPageListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16315,7 +16311,7 @@ impl<'a, C, NC, A> LandingPageListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> LandingPageListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> LandingPageListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -16325,7 +16321,7 @@ impl<'a, C, NC, A> LandingPageListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Landing page campaign ID. - pub fn campaign_id(mut self, new_value: &str) -> LandingPageListCall<'a, C, NC, A> { + pub fn campaign_id(mut self, new_value: &str) -> LandingPageListCall<'a, C, A> { self._campaign_id = new_value.to_string(); self } @@ -16336,7 +16332,7 @@ impl<'a, C, NC, A> LandingPageListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LandingPageListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LandingPageListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16357,7 +16353,7 @@ impl<'a, C, NC, A> LandingPageListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LandingPageListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LandingPageListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16374,7 +16370,7 @@ impl<'a, C, NC, A> LandingPageListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LandingPageListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LandingPageListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16418,10 +16414,10 @@ impl<'a, C, NC, A> LandingPageListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct LandingPageInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LandingPageInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: LandingPage, _profile_id: String, _campaign_id: String, @@ -16430,9 +16426,9 @@ pub struct LandingPageInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LandingPageInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LandingPageInsertCall<'a, C, A> {} -impl<'a, C, NC, A> LandingPageInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LandingPageInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16572,7 +16568,7 @@ impl<'a, C, NC, A> LandingPageInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &LandingPage) -> LandingPageInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &LandingPage) -> LandingPageInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -16582,7 +16578,7 @@ impl<'a, C, NC, A> LandingPageInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> LandingPageInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> LandingPageInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -16592,7 +16588,7 @@ impl<'a, C, NC, A> LandingPageInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Landing page campaign ID. - pub fn campaign_id(mut self, new_value: &str) -> LandingPageInsertCall<'a, C, NC, A> { + pub fn campaign_id(mut self, new_value: &str) -> LandingPageInsertCall<'a, C, A> { self._campaign_id = new_value.to_string(); self } @@ -16603,7 +16599,7 @@ impl<'a, C, NC, A> LandingPageInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LandingPageInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LandingPageInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16624,7 +16620,7 @@ impl<'a, C, NC, A> LandingPageInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LandingPageInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LandingPageInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16641,7 +16637,7 @@ impl<'a, C, NC, A> LandingPageInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LandingPageInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LandingPageInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16685,10 +16681,10 @@ impl<'a, C, NC, A> LandingPageInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct LandingPagePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LandingPagePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: LandingPage, _profile_id: String, _campaign_id: String, @@ -16698,9 +16694,9 @@ pub struct LandingPagePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LandingPagePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LandingPagePatchCall<'a, C, A> {} -impl<'a, C, NC, A> LandingPagePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LandingPagePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16841,7 +16837,7 @@ impl<'a, C, NC, A> LandingPagePatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &LandingPage) -> LandingPagePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &LandingPage) -> LandingPagePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -16851,7 +16847,7 @@ impl<'a, C, NC, A> LandingPagePatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> LandingPagePatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> LandingPagePatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -16861,7 +16857,7 @@ impl<'a, C, NC, A> LandingPagePatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Landing page campaign ID. - pub fn campaign_id(mut self, new_value: &str) -> LandingPagePatchCall<'a, C, NC, A> { + pub fn campaign_id(mut self, new_value: &str) -> LandingPagePatchCall<'a, C, A> { self._campaign_id = new_value.to_string(); self } @@ -16871,7 +16867,7 @@ impl<'a, C, NC, A> LandingPagePatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Landing page ID. - pub fn id(mut self, new_value: &str) -> LandingPagePatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> LandingPagePatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -16882,7 +16878,7 @@ impl<'a, C, NC, A> LandingPagePatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LandingPagePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LandingPagePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16903,7 +16899,7 @@ impl<'a, C, NC, A> LandingPagePatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LandingPagePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LandingPagePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16920,7 +16916,7 @@ impl<'a, C, NC, A> LandingPagePatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LandingPagePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LandingPagePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16958,10 +16954,10 @@ impl<'a, C, NC, A> LandingPagePatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct LandingPageDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LandingPageDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _campaign_id: String, _id: String, @@ -16970,9 +16966,9 @@ pub struct LandingPageDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LandingPageDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LandingPageDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> LandingPageDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LandingPageDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17095,7 +17091,7 @@ impl<'a, C, NC, A> LandingPageDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> LandingPageDeleteCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> LandingPageDeleteCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -17105,7 +17101,7 @@ impl<'a, C, NC, A> LandingPageDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Landing page campaign ID. - pub fn campaign_id(mut self, new_value: &str) -> LandingPageDeleteCall<'a, C, NC, A> { + pub fn campaign_id(mut self, new_value: &str) -> LandingPageDeleteCall<'a, C, A> { self._campaign_id = new_value.to_string(); self } @@ -17115,7 +17111,7 @@ impl<'a, C, NC, A> LandingPageDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Landing page ID. - pub fn id(mut self, new_value: &str) -> LandingPageDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> LandingPageDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -17126,7 +17122,7 @@ impl<'a, C, NC, A> LandingPageDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LandingPageDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LandingPageDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17147,7 +17143,7 @@ impl<'a, C, NC, A> LandingPageDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LandingPageDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LandingPageDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17164,7 +17160,7 @@ impl<'a, C, NC, A> LandingPageDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LandingPageDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LandingPageDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17208,10 +17204,10 @@ impl<'a, C, NC, A> LandingPageDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct CampaignCreativeAssociationInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CampaignCreativeAssociationInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: CampaignCreativeAssociation, _profile_id: String, _campaign_id: String, @@ -17220,9 +17216,9 @@ pub struct CampaignCreativeAssociationInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CampaignCreativeAssociationInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CampaignCreativeAssociationInsertCall<'a, C, A> {} -impl<'a, C, NC, A> CampaignCreativeAssociationInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CampaignCreativeAssociationInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17362,7 +17358,7 @@ impl<'a, C, NC, A> CampaignCreativeAssociationInsertCall<'a, C, NC, A> where NC: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CampaignCreativeAssociation) -> CampaignCreativeAssociationInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CampaignCreativeAssociation) -> CampaignCreativeAssociationInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -17372,7 +17368,7 @@ impl<'a, C, NC, A> CampaignCreativeAssociationInsertCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CampaignCreativeAssociationInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CampaignCreativeAssociationInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -17382,7 +17378,7 @@ impl<'a, C, NC, A> CampaignCreativeAssociationInsertCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Campaign ID in this association. - pub fn campaign_id(mut self, new_value: &str) -> CampaignCreativeAssociationInsertCall<'a, C, NC, A> { + pub fn campaign_id(mut self, new_value: &str) -> CampaignCreativeAssociationInsertCall<'a, C, A> { self._campaign_id = new_value.to_string(); self } @@ -17393,7 +17389,7 @@ impl<'a, C, NC, A> CampaignCreativeAssociationInsertCall<'a, C, NC, A> where NC: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CampaignCreativeAssociationInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CampaignCreativeAssociationInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17414,7 +17410,7 @@ impl<'a, C, NC, A> CampaignCreativeAssociationInsertCall<'a, C, NC, A> where NC: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CampaignCreativeAssociationInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CampaignCreativeAssociationInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17431,7 +17427,7 @@ impl<'a, C, NC, A> CampaignCreativeAssociationInsertCall<'a, C, NC, A> where NC: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CampaignCreativeAssociationInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CampaignCreativeAssociationInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17472,10 +17468,10 @@ impl<'a, C, NC, A> CampaignCreativeAssociationInsertCall<'a, C, NC, A> where NC: /// .doit(); /// # } /// ``` -pub struct CampaignCreativeAssociationListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CampaignCreativeAssociationListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _campaign_id: String, _sort_order: Option, @@ -17486,9 +17482,9 @@ pub struct CampaignCreativeAssociationListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CampaignCreativeAssociationListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CampaignCreativeAssociationListCall<'a, C, A> {} -impl<'a, C, NC, A> CampaignCreativeAssociationListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CampaignCreativeAssociationListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17630,7 +17626,7 @@ impl<'a, C, NC, A> CampaignCreativeAssociationListCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CampaignCreativeAssociationListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CampaignCreativeAssociationListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -17640,7 +17636,7 @@ impl<'a, C, NC, A> CampaignCreativeAssociationListCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Campaign ID in this association. - pub fn campaign_id(mut self, new_value: &str) -> CampaignCreativeAssociationListCall<'a, C, NC, A> { + pub fn campaign_id(mut self, new_value: &str) -> CampaignCreativeAssociationListCall<'a, C, A> { self._campaign_id = new_value.to_string(); self } @@ -17648,7 +17644,7 @@ impl<'a, C, NC, A> CampaignCreativeAssociationListCall<'a, C, NC, A> where NC: h /// /// /// Order of sorted results, default is ASCENDING. - pub fn sort_order(mut self, new_value: &str) -> CampaignCreativeAssociationListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> CampaignCreativeAssociationListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -17656,7 +17652,7 @@ impl<'a, C, NC, A> CampaignCreativeAssociationListCall<'a, C, NC, A> where NC: h /// /// /// Value of the nextPageToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> CampaignCreativeAssociationListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> CampaignCreativeAssociationListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -17664,7 +17660,7 @@ impl<'a, C, NC, A> CampaignCreativeAssociationListCall<'a, C, NC, A> where NC: h /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> CampaignCreativeAssociationListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> CampaignCreativeAssociationListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -17675,7 +17671,7 @@ impl<'a, C, NC, A> CampaignCreativeAssociationListCall<'a, C, NC, A> where NC: h /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CampaignCreativeAssociationListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CampaignCreativeAssociationListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17696,7 +17692,7 @@ impl<'a, C, NC, A> CampaignCreativeAssociationListCall<'a, C, NC, A> where NC: h /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CampaignCreativeAssociationListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CampaignCreativeAssociationListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17713,7 +17709,7 @@ impl<'a, C, NC, A> CampaignCreativeAssociationListCall<'a, C, NC, A> where NC: h /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CampaignCreativeAssociationListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CampaignCreativeAssociationListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17761,10 +17757,10 @@ impl<'a, C, NC, A> CampaignCreativeAssociationListCall<'a, C, NC, A> where NC: h /// .doit(); /// # } /// ``` -pub struct ChangeLogListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChangeLogListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _user_profile_ids: Vec, _search_string: Option, @@ -17781,9 +17777,9 @@ pub struct ChangeLogListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChangeLogListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChangeLogListCall<'a, C, A> {} -impl<'a, C, NC, A> ChangeLogListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChangeLogListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17957,7 +17953,7 @@ impl<'a, C, NC, A> ChangeLogListCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> ChangeLogListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ChangeLogListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -17966,7 +17962,7 @@ impl<'a, C, NC, A> ChangeLogListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Select only change logs with these user profile IDs. - pub fn add_user_profile_ids(mut self, new_value: &str) -> ChangeLogListCall<'a, C, NC, A> { + pub fn add_user_profile_ids(mut self, new_value: &str) -> ChangeLogListCall<'a, C, A> { self._user_profile_ids.push(new_value.to_string()); self } @@ -17974,7 +17970,7 @@ impl<'a, C, NC, A> ChangeLogListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Select only change logs whose object ID, user name, old or new values match the search string. - pub fn search_string(mut self, new_value: &str) -> ChangeLogListCall<'a, C, NC, A> { + pub fn search_string(mut self, new_value: &str) -> ChangeLogListCall<'a, C, A> { self._search_string = Some(new_value.to_string()); self } @@ -17982,7 +17978,7 @@ impl<'a, C, NC, A> ChangeLogListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Value of the nextPageToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> ChangeLogListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ChangeLogListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -17990,7 +17986,7 @@ impl<'a, C, NC, A> ChangeLogListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Select only change logs with the specified object type. - pub fn object_type(mut self, new_value: &str) -> ChangeLogListCall<'a, C, NC, A> { + pub fn object_type(mut self, new_value: &str) -> ChangeLogListCall<'a, C, A> { self._object_type = Some(new_value.to_string()); self } @@ -17999,7 +17995,7 @@ impl<'a, C, NC, A> ChangeLogListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Select only change logs with these object IDs. - pub fn add_object_ids(mut self, new_value: &str) -> ChangeLogListCall<'a, C, NC, A> { + pub fn add_object_ids(mut self, new_value: &str) -> ChangeLogListCall<'a, C, A> { self._object_ids.push(new_value.to_string()); self } @@ -18007,7 +18003,7 @@ impl<'a, C, NC, A> ChangeLogListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Select only change logs whose change time is before the specified minChangeTime.The time should be formatted as an RFC3339 date/time string. For example, for 10:54 PM on July 18th, 2015, in the America/New York time zone, the format is "2015-07-18T22:54:00-04:00". In other words, the year, month, day, the letter T, the hour (24-hour clock system), minute, second, and then the time zone offset. - pub fn min_change_time(mut self, new_value: &str) -> ChangeLogListCall<'a, C, NC, A> { + pub fn min_change_time(mut self, new_value: &str) -> ChangeLogListCall<'a, C, A> { self._min_change_time = Some(new_value.to_string()); self } @@ -18015,7 +18011,7 @@ impl<'a, C, NC, A> ChangeLogListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> ChangeLogListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ChangeLogListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -18023,7 +18019,7 @@ impl<'a, C, NC, A> ChangeLogListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Select only change logs whose change time is before the specified maxChangeTime.The time should be formatted as an RFC3339 date/time string. For example, for 10:54 PM on July 18th, 2015, in the America/New York time zone, the format is "2015-07-18T22:54:00-04:00". In other words, the year, month, day, the letter T, the hour (24-hour clock system), minute, second, and then the time zone offset. - pub fn max_change_time(mut self, new_value: &str) -> ChangeLogListCall<'a, C, NC, A> { + pub fn max_change_time(mut self, new_value: &str) -> ChangeLogListCall<'a, C, A> { self._max_change_time = Some(new_value.to_string()); self } @@ -18032,7 +18028,7 @@ impl<'a, C, NC, A> ChangeLogListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Select only change logs with these IDs. - pub fn add_ids(mut self, new_value: &str) -> ChangeLogListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> ChangeLogListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -18040,7 +18036,7 @@ impl<'a, C, NC, A> ChangeLogListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Select only change logs with the specified action. - pub fn action(mut self, new_value: &str) -> ChangeLogListCall<'a, C, NC, A> { + pub fn action(mut self, new_value: &str) -> ChangeLogListCall<'a, C, A> { self._action = Some(new_value.to_string()); self } @@ -18051,7 +18047,7 @@ impl<'a, C, NC, A> ChangeLogListCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChangeLogListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChangeLogListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18072,7 +18068,7 @@ impl<'a, C, NC, A> ChangeLogListCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChangeLogListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChangeLogListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18089,7 +18085,7 @@ impl<'a, C, NC, A> ChangeLogListCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChangeLogListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChangeLogListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18127,10 +18123,10 @@ impl<'a, C, NC, A> ChangeLogListCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct ChangeLogGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChangeLogGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -18138,9 +18134,9 @@ pub struct ChangeLogGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChangeLogGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChangeLogGetCall<'a, C, A> {} -impl<'a, C, NC, A> ChangeLogGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChangeLogGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18273,7 +18269,7 @@ impl<'a, C, NC, A> ChangeLogGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> ChangeLogGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ChangeLogGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -18283,7 +18279,7 @@ impl<'a, C, NC, A> ChangeLogGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Change log ID. - pub fn id(mut self, new_value: &str) -> ChangeLogGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> ChangeLogGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -18294,7 +18290,7 @@ impl<'a, C, NC, A> ChangeLogGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChangeLogGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChangeLogGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18315,7 +18311,7 @@ impl<'a, C, NC, A> ChangeLogGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChangeLogGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChangeLogGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18332,7 +18328,7 @@ impl<'a, C, NC, A> ChangeLogGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChangeLogGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChangeLogGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18370,10 +18366,10 @@ impl<'a, C, NC, A> ChangeLogGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct AccountGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -18381,9 +18377,9 @@ pub struct AccountGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18516,7 +18512,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AccountGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AccountGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -18526,7 +18522,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Account ID. - pub fn id(mut self, new_value: &str) -> AccountGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> AccountGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -18537,7 +18533,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18558,7 +18554,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18575,7 +18571,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18620,10 +18616,10 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct AccountListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _sort_order: Option, _sort_field: Option, @@ -18637,9 +18633,9 @@ pub struct AccountListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18796,7 +18792,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AccountListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AccountListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -18804,7 +18800,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Order of sorted results, default is ASCENDING. - pub fn sort_order(mut self, new_value: &str) -> AccountListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> AccountListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -18812,7 +18808,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> AccountListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> AccountListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -18820,7 +18816,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Allows searching for objects by name or ID. Wildcards (*) are allowed. For example, "account*2015" will return objects with names like "account June 2015", "account April 2015", or simply "account 2015". Most of the searches also add wildcards implicitly at the start and the end of the search string. For example, a search string of "account" will match objects with name "my account", "account 2015", or simply "account". - pub fn search_string(mut self, new_value: &str) -> AccountListCall<'a, C, NC, A> { + pub fn search_string(mut self, new_value: &str) -> AccountListCall<'a, C, A> { self._search_string = Some(new_value.to_string()); self } @@ -18828,7 +18824,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Value of the nextPageToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> AccountListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AccountListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -18836,7 +18832,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> AccountListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AccountListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -18845,7 +18841,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Select only accounts with these IDs. - pub fn add_ids(mut self, new_value: &str) -> AccountListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> AccountListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -18853,7 +18849,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Select only active accounts. Don't set this field to select both active and non-active accounts. - pub fn active(mut self, new_value: bool) -> AccountListCall<'a, C, NC, A> { + pub fn active(mut self, new_value: bool) -> AccountListCall<'a, C, A> { self._active = Some(new_value); self } @@ -18864,7 +18860,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18885,7 +18881,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18902,7 +18898,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18946,10 +18942,10 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct AccountUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Account, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -18957,9 +18953,9 @@ pub struct AccountUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19098,7 +19094,7 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Account) -> AccountUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Account) -> AccountUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -19108,7 +19104,7 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AccountUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AccountUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -19119,7 +19115,7 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19140,7 +19136,7 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19157,7 +19153,7 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19201,10 +19197,10 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct AccountPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Account, _profile_id: String, _id: String, @@ -19213,9 +19209,9 @@ pub struct AccountPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountPatchCall<'a, C, A> {} -impl<'a, C, NC, A> AccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19355,7 +19351,7 @@ impl<'a, C, NC, A> AccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Account) -> AccountPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Account) -> AccountPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -19365,7 +19361,7 @@ impl<'a, C, NC, A> AccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AccountPatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AccountPatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -19375,7 +19371,7 @@ impl<'a, C, NC, A> AccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Account ID. - pub fn id(mut self, new_value: &str) -> AccountPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> AccountPatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -19386,7 +19382,7 @@ impl<'a, C, NC, A> AccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19407,7 +19403,7 @@ impl<'a, C, NC, A> AccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19424,7 +19420,7 @@ impl<'a, C, NC, A> AccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19462,19 +19458,19 @@ impl<'a, C, NC, A> AccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct PostalCodeListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PostalCodeListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PostalCodeListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PostalCodeListCall<'a, C, A> {} -impl<'a, C, NC, A> PostalCodeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PostalCodeListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19606,7 +19602,7 @@ impl<'a, C, NC, A> PostalCodeListCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> PostalCodeListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> PostalCodeListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -19617,7 +19613,7 @@ impl<'a, C, NC, A> PostalCodeListCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostalCodeListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PostalCodeListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19638,7 +19634,7 @@ impl<'a, C, NC, A> PostalCodeListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PostalCodeListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PostalCodeListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19655,7 +19651,7 @@ impl<'a, C, NC, A> PostalCodeListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PostalCodeListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PostalCodeListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19699,10 +19695,10 @@ impl<'a, C, NC, A> PostalCodeListCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct AdvertiserInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdvertiserInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Advertiser, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -19710,9 +19706,9 @@ pub struct AdvertiserInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AdvertiserInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdvertiserInsertCall<'a, C, A> {} -impl<'a, C, NC, A> AdvertiserInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdvertiserInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19851,7 +19847,7 @@ impl<'a, C, NC, A> AdvertiserInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Advertiser) -> AdvertiserInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Advertiser) -> AdvertiserInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -19861,7 +19857,7 @@ impl<'a, C, NC, A> AdvertiserInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AdvertiserInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AdvertiserInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -19872,7 +19868,7 @@ impl<'a, C, NC, A> AdvertiserInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19893,7 +19889,7 @@ impl<'a, C, NC, A> AdvertiserInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdvertiserInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdvertiserInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19910,7 +19906,7 @@ impl<'a, C, NC, A> AdvertiserInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AdvertiserInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AdvertiserInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19954,10 +19950,10 @@ impl<'a, C, NC, A> AdvertiserInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct AdvertiserPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdvertiserPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Advertiser, _profile_id: String, _id: String, @@ -19966,9 +19962,9 @@ pub struct AdvertiserPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AdvertiserPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdvertiserPatchCall<'a, C, A> {} -impl<'a, C, NC, A> AdvertiserPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdvertiserPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -20108,7 +20104,7 @@ impl<'a, C, NC, A> AdvertiserPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Advertiser) -> AdvertiserPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Advertiser) -> AdvertiserPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -20118,7 +20114,7 @@ impl<'a, C, NC, A> AdvertiserPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AdvertiserPatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AdvertiserPatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -20128,7 +20124,7 @@ impl<'a, C, NC, A> AdvertiserPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Advertiser ID. - pub fn id(mut self, new_value: &str) -> AdvertiserPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> AdvertiserPatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -20139,7 +20135,7 @@ impl<'a, C, NC, A> AdvertiserPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -20160,7 +20156,7 @@ impl<'a, C, NC, A> AdvertiserPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdvertiserPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdvertiserPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -20177,7 +20173,7 @@ impl<'a, C, NC, A> AdvertiserPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AdvertiserPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AdvertiserPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -20227,10 +20223,10 @@ impl<'a, C, NC, A> AdvertiserPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct AdvertiserListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdvertiserListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _subaccount_id: Option, _status: Option, @@ -20249,9 +20245,9 @@ pub struct AdvertiserListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AdvertiserListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdvertiserListCall<'a, C, A> {} -impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdvertiserListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -20431,7 +20427,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AdvertiserListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AdvertiserListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -20439,7 +20435,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Select only advertisers with these subaccount IDs. - pub fn subaccount_id(mut self, new_value: &str) -> AdvertiserListCall<'a, C, NC, A> { + pub fn subaccount_id(mut self, new_value: &str) -> AdvertiserListCall<'a, C, A> { self._subaccount_id = Some(new_value.to_string()); self } @@ -20447,7 +20443,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Select only advertisers with the specified status. - pub fn status(mut self, new_value: &str) -> AdvertiserListCall<'a, C, NC, A> { + pub fn status(mut self, new_value: &str) -> AdvertiserListCall<'a, C, A> { self._status = Some(new_value.to_string()); self } @@ -20455,7 +20451,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Order of sorted results, default is ASCENDING. - pub fn sort_order(mut self, new_value: &str) -> AdvertiserListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> AdvertiserListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -20463,7 +20459,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> AdvertiserListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> AdvertiserListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -20471,7 +20467,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Allows searching for objects by name or ID. Wildcards (*) are allowed. For example, "advertiser*2015" will return objects with names like "advertiser June 2015", "advertiser April 2015", or simply "advertiser 2015". Most of the searches also add wildcards implicitly at the start and the end of the search string. For example, a search string of "advertiser" will match objects with name "my advertiser", "advertiser 2015", or simply "advertiser". - pub fn search_string(mut self, new_value: &str) -> AdvertiserListCall<'a, C, NC, A> { + pub fn search_string(mut self, new_value: &str) -> AdvertiserListCall<'a, C, A> { self._search_string = Some(new_value.to_string()); self } @@ -20479,7 +20475,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Value of the nextPageToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> AdvertiserListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AdvertiserListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -20487,7 +20483,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Select only advertisers which use another advertiser's floodlight configuration. - pub fn only_parent(mut self, new_value: bool) -> AdvertiserListCall<'a, C, NC, A> { + pub fn only_parent(mut self, new_value: bool) -> AdvertiserListCall<'a, C, A> { self._only_parent = Some(new_value); self } @@ -20495,7 +20491,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> AdvertiserListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AdvertiserListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -20503,7 +20499,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Select only advertisers which do not belong to any advertiser group. - pub fn include_advertisers_without_groups_only(mut self, new_value: bool) -> AdvertiserListCall<'a, C, NC, A> { + pub fn include_advertisers_without_groups_only(mut self, new_value: bool) -> AdvertiserListCall<'a, C, A> { self._include_advertisers_without_groups_only = Some(new_value); self } @@ -20512,7 +20508,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Select only advertisers with these IDs. - pub fn add_ids(mut self, new_value: &str) -> AdvertiserListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> AdvertiserListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -20521,7 +20517,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Select only advertisers with these floodlight configuration IDs. - pub fn add_floodlight_configuration_ids(mut self, new_value: &str) -> AdvertiserListCall<'a, C, NC, A> { + pub fn add_floodlight_configuration_ids(mut self, new_value: &str) -> AdvertiserListCall<'a, C, A> { self._floodlight_configuration_ids.push(new_value.to_string()); self } @@ -20530,7 +20526,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Select only advertisers with these advertiser group IDs. - pub fn add_advertiser_group_ids(mut self, new_value: &str) -> AdvertiserListCall<'a, C, NC, A> { + pub fn add_advertiser_group_ids(mut self, new_value: &str) -> AdvertiserListCall<'a, C, A> { self._advertiser_group_ids.push(new_value.to_string()); self } @@ -20541,7 +20537,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -20562,7 +20558,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdvertiserListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdvertiserListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -20579,7 +20575,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AdvertiserListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AdvertiserListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -20623,10 +20619,10 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct AdvertiserUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdvertiserUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Advertiser, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -20634,9 +20630,9 @@ pub struct AdvertiserUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AdvertiserUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdvertiserUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AdvertiserUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdvertiserUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -20775,7 +20771,7 @@ impl<'a, C, NC, A> AdvertiserUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Advertiser) -> AdvertiserUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Advertiser) -> AdvertiserUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -20785,7 +20781,7 @@ impl<'a, C, NC, A> AdvertiserUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AdvertiserUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AdvertiserUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -20796,7 +20792,7 @@ impl<'a, C, NC, A> AdvertiserUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -20817,7 +20813,7 @@ impl<'a, C, NC, A> AdvertiserUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdvertiserUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdvertiserUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -20834,7 +20830,7 @@ impl<'a, C, NC, A> AdvertiserUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AdvertiserUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AdvertiserUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -20872,10 +20868,10 @@ impl<'a, C, NC, A> AdvertiserUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct AdvertiserGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdvertiserGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -20883,9 +20879,9 @@ pub struct AdvertiserGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AdvertiserGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdvertiserGetCall<'a, C, A> {} -impl<'a, C, NC, A> AdvertiserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdvertiserGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -21018,7 +21014,7 @@ impl<'a, C, NC, A> AdvertiserGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AdvertiserGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AdvertiserGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -21028,7 +21024,7 @@ impl<'a, C, NC, A> AdvertiserGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Advertiser ID. - pub fn id(mut self, new_value: &str) -> AdvertiserGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> AdvertiserGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -21039,7 +21035,7 @@ impl<'a, C, NC, A> AdvertiserGetCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -21060,7 +21056,7 @@ impl<'a, C, NC, A> AdvertiserGetCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdvertiserGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdvertiserGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -21077,7 +21073,7 @@ impl<'a, C, NC, A> AdvertiserGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AdvertiserGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AdvertiserGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -21123,10 +21119,10 @@ impl<'a, C, NC, A> AdvertiserGetCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct DimensionValueQueryCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DimensionValueQueryCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: DimensionValueRequest, _profile_id: String, _page_token: Option, @@ -21136,9 +21132,9 @@ pub struct DimensionValueQueryCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DimensionValueQueryCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DimensionValueQueryCall<'a, C, A> {} -impl<'a, C, NC, A> DimensionValueQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DimensionValueQueryCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -21283,7 +21279,7 @@ impl<'a, C, NC, A> DimensionValueQueryCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &DimensionValueRequest) -> DimensionValueQueryCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &DimensionValueRequest) -> DimensionValueQueryCall<'a, C, A> { self._request = new_value.clone(); self } @@ -21293,7 +21289,7 @@ impl<'a, C, NC, A> DimensionValueQueryCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The DFA user profile ID. - pub fn profile_id(mut self, new_value: &str) -> DimensionValueQueryCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> DimensionValueQueryCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -21301,7 +21297,7 @@ impl<'a, C, NC, A> DimensionValueQueryCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The value of the nextToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> DimensionValueQueryCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> DimensionValueQueryCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -21309,7 +21305,7 @@ impl<'a, C, NC, A> DimensionValueQueryCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> DimensionValueQueryCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> DimensionValueQueryCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -21320,7 +21316,7 @@ impl<'a, C, NC, A> DimensionValueQueryCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DimensionValueQueryCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DimensionValueQueryCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -21341,7 +21337,7 @@ impl<'a, C, NC, A> DimensionValueQueryCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DimensionValueQueryCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DimensionValueQueryCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -21358,7 +21354,7 @@ impl<'a, C, NC, A> DimensionValueQueryCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DimensionValueQueryCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DimensionValueQueryCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -21396,10 +21392,10 @@ impl<'a, C, NC, A> DimensionValueQueryCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct FloodlightActivityGroupDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FloodlightActivityGroupDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -21407,9 +21403,9 @@ pub struct FloodlightActivityGroupDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FloodlightActivityGroupDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FloodlightActivityGroupDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> FloodlightActivityGroupDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FloodlightActivityGroupDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -21531,7 +21527,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupDeleteCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityGroupDeleteCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityGroupDeleteCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -21541,7 +21537,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupDeleteCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// Floodlight activity Group ID. - pub fn id(mut self, new_value: &str) -> FloodlightActivityGroupDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> FloodlightActivityGroupDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -21552,7 +21548,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupDeleteCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityGroupDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityGroupDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -21573,7 +21569,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupDeleteCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FloodlightActivityGroupDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FloodlightActivityGroupDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -21590,7 +21586,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupDeleteCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FloodlightActivityGroupDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FloodlightActivityGroupDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -21628,10 +21624,10 @@ impl<'a, C, NC, A> FloodlightActivityGroupDeleteCall<'a, C, NC, A> where NC: hyp /// .doit(); /// # } /// ``` -pub struct FloodlightActivityGroupGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FloodlightActivityGroupGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -21639,9 +21635,9 @@ pub struct FloodlightActivityGroupGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FloodlightActivityGroupGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FloodlightActivityGroupGetCall<'a, C, A> {} -impl<'a, C, NC, A> FloodlightActivityGroupGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FloodlightActivityGroupGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -21774,7 +21770,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupGetCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityGroupGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityGroupGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -21784,7 +21780,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupGetCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Floodlight activity Group ID. - pub fn id(mut self, new_value: &str) -> FloodlightActivityGroupGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> FloodlightActivityGroupGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -21795,7 +21791,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupGetCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityGroupGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityGroupGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -21816,7 +21812,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupGetCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FloodlightActivityGroupGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FloodlightActivityGroupGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -21833,7 +21829,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupGetCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FloodlightActivityGroupGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FloodlightActivityGroupGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -21877,10 +21873,10 @@ impl<'a, C, NC, A> FloodlightActivityGroupGetCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct FloodlightActivityGroupPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FloodlightActivityGroupPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: FloodlightActivityGroup, _profile_id: String, _id: String, @@ -21889,9 +21885,9 @@ pub struct FloodlightActivityGroupPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FloodlightActivityGroupPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FloodlightActivityGroupPatchCall<'a, C, A> {} -impl<'a, C, NC, A> FloodlightActivityGroupPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FloodlightActivityGroupPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -22031,7 +22027,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupPatchCall<'a, C, NC, A> where NC: hype /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &FloodlightActivityGroup) -> FloodlightActivityGroupPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &FloodlightActivityGroup) -> FloodlightActivityGroupPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -22041,7 +22037,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupPatchCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityGroupPatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityGroupPatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -22051,7 +22047,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupPatchCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// Floodlight activity Group ID. - pub fn id(mut self, new_value: &str) -> FloodlightActivityGroupPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> FloodlightActivityGroupPatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -22062,7 +22058,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupPatchCall<'a, C, NC, A> where NC: hype /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityGroupPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityGroupPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -22083,7 +22079,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupPatchCall<'a, C, NC, A> where NC: hype /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FloodlightActivityGroupPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FloodlightActivityGroupPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -22100,7 +22096,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupPatchCall<'a, C, NC, A> where NC: hype /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FloodlightActivityGroupPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FloodlightActivityGroupPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -22147,10 +22143,10 @@ impl<'a, C, NC, A> FloodlightActivityGroupPatchCall<'a, C, NC, A> where NC: hype /// .doit(); /// # } /// ``` -pub struct FloodlightActivityGroupListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FloodlightActivityGroupListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _type_: Option, _sort_order: Option, @@ -22166,9 +22162,9 @@ pub struct FloodlightActivityGroupListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FloodlightActivityGroupListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FloodlightActivityGroupListCall<'a, C, A> {} -impl<'a, C, NC, A> FloodlightActivityGroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FloodlightActivityGroupListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -22331,7 +22327,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupListCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityGroupListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityGroupListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -22339,7 +22335,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupListCall<'a, C, NC, A> where NC: hyper /// /// /// Select only floodlight activity groups with the specified floodlight activity group type. - pub fn type_(mut self, new_value: &str) -> FloodlightActivityGroupListCall<'a, C, NC, A> { + pub fn type_(mut self, new_value: &str) -> FloodlightActivityGroupListCall<'a, C, A> { self._type_ = Some(new_value.to_string()); self } @@ -22347,7 +22343,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupListCall<'a, C, NC, A> where NC: hyper /// /// /// Order of sorted results, default is ASCENDING. - pub fn sort_order(mut self, new_value: &str) -> FloodlightActivityGroupListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> FloodlightActivityGroupListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -22355,7 +22351,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupListCall<'a, C, NC, A> where NC: hyper /// /// /// Field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> FloodlightActivityGroupListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> FloodlightActivityGroupListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -22363,7 +22359,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupListCall<'a, C, NC, A> where NC: hyper /// /// /// Allows searching for objects by name or ID. Wildcards (*) are allowed. For example, "floodlightactivitygroup*2015" will return objects with names like "floodlightactivitygroup June 2015", "floodlightactivitygroup April 2015", or simply "floodlightactivitygroup 2015". Most of the searches also add wildcards implicitly at the start and the end of the search string. For example, a search string of "floodlightactivitygroup" will match objects with name "my floodlightactivitygroup activity", "floodlightactivitygroup 2015", or simply "floodlightactivitygroup". - pub fn search_string(mut self, new_value: &str) -> FloodlightActivityGroupListCall<'a, C, NC, A> { + pub fn search_string(mut self, new_value: &str) -> FloodlightActivityGroupListCall<'a, C, A> { self._search_string = Some(new_value.to_string()); self } @@ -22371,7 +22367,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupListCall<'a, C, NC, A> where NC: hyper /// /// /// Value of the nextPageToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> FloodlightActivityGroupListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> FloodlightActivityGroupListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -22379,7 +22375,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupListCall<'a, C, NC, A> where NC: hyper /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> FloodlightActivityGroupListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> FloodlightActivityGroupListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -22388,7 +22384,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupListCall<'a, C, NC, A> where NC: hyper /// /// /// Select only floodlight activity groups with the specified IDs. Must specify either advertiserId or floodlightConfigurationId for a non-empty result. - pub fn add_ids(mut self, new_value: &str) -> FloodlightActivityGroupListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> FloodlightActivityGroupListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -22396,7 +22392,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupListCall<'a, C, NC, A> where NC: hyper /// /// /// Select only floodlight activity groups with the specified floodlight configuration ID. Must specify either advertiserId, or floodlightConfigurationId for a non-empty result. - pub fn floodlight_configuration_id(mut self, new_value: &str) -> FloodlightActivityGroupListCall<'a, C, NC, A> { + pub fn floodlight_configuration_id(mut self, new_value: &str) -> FloodlightActivityGroupListCall<'a, C, A> { self._floodlight_configuration_id = Some(new_value.to_string()); self } @@ -22404,7 +22400,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupListCall<'a, C, NC, A> where NC: hyper /// /// /// Select only floodlight activity groups with the specified advertiser ID. Must specify either advertiserId or floodlightConfigurationId for a non-empty result. - pub fn advertiser_id(mut self, new_value: &str) -> FloodlightActivityGroupListCall<'a, C, NC, A> { + pub fn advertiser_id(mut self, new_value: &str) -> FloodlightActivityGroupListCall<'a, C, A> { self._advertiser_id = Some(new_value.to_string()); self } @@ -22415,7 +22411,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupListCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityGroupListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityGroupListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -22436,7 +22432,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupListCall<'a, C, NC, A> where NC: hyper /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FloodlightActivityGroupListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FloodlightActivityGroupListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -22453,7 +22449,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupListCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FloodlightActivityGroupListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FloodlightActivityGroupListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -22497,10 +22493,10 @@ impl<'a, C, NC, A> FloodlightActivityGroupListCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct FloodlightActivityGroupInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FloodlightActivityGroupInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: FloodlightActivityGroup, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -22508,9 +22504,9 @@ pub struct FloodlightActivityGroupInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FloodlightActivityGroupInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FloodlightActivityGroupInsertCall<'a, C, A> {} -impl<'a, C, NC, A> FloodlightActivityGroupInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FloodlightActivityGroupInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -22649,7 +22645,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupInsertCall<'a, C, NC, A> where NC: hyp /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &FloodlightActivityGroup) -> FloodlightActivityGroupInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &FloodlightActivityGroup) -> FloodlightActivityGroupInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -22659,7 +22655,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupInsertCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityGroupInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityGroupInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -22670,7 +22666,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupInsertCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityGroupInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityGroupInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -22691,7 +22687,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupInsertCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FloodlightActivityGroupInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FloodlightActivityGroupInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -22708,7 +22704,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupInsertCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FloodlightActivityGroupInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FloodlightActivityGroupInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -22752,10 +22748,10 @@ impl<'a, C, NC, A> FloodlightActivityGroupInsertCall<'a, C, NC, A> where NC: hyp /// .doit(); /// # } /// ``` -pub struct FloodlightActivityGroupUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FloodlightActivityGroupUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: FloodlightActivityGroup, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -22763,9 +22759,9 @@ pub struct FloodlightActivityGroupUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FloodlightActivityGroupUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FloodlightActivityGroupUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> FloodlightActivityGroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FloodlightActivityGroupUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -22904,7 +22900,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupUpdateCall<'a, C, NC, A> where NC: hyp /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &FloodlightActivityGroup) -> FloodlightActivityGroupUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &FloodlightActivityGroup) -> FloodlightActivityGroupUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -22914,7 +22910,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupUpdateCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityGroupUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityGroupUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -22925,7 +22921,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupUpdateCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityGroupUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityGroupUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -22946,7 +22942,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupUpdateCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FloodlightActivityGroupUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FloodlightActivityGroupUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -22963,7 +22959,7 @@ impl<'a, C, NC, A> FloodlightActivityGroupUpdateCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FloodlightActivityGroupUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FloodlightActivityGroupUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -23001,19 +22997,19 @@ impl<'a, C, NC, A> FloodlightActivityGroupUpdateCall<'a, C, NC, A> where NC: hyp /// .doit(); /// # } /// ``` -pub struct MetroListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MetroListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MetroListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MetroListCall<'a, C, A> {} -impl<'a, C, NC, A> MetroListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MetroListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -23145,7 +23141,7 @@ impl<'a, C, NC, A> MetroListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> MetroListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> MetroListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -23156,7 +23152,7 @@ impl<'a, C, NC, A> MetroListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MetroListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MetroListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -23177,7 +23173,7 @@ impl<'a, C, NC, A> MetroListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MetroListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MetroListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -23194,7 +23190,7 @@ impl<'a, C, NC, A> MetroListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MetroListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MetroListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -23232,10 +23228,10 @@ impl<'a, C, NC, A> MetroListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct DirectorySiteContactGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DirectorySiteContactGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -23243,9 +23239,9 @@ pub struct DirectorySiteContactGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DirectorySiteContactGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DirectorySiteContactGetCall<'a, C, A> {} -impl<'a, C, NC, A> DirectorySiteContactGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DirectorySiteContactGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -23378,7 +23374,7 @@ impl<'a, C, NC, A> DirectorySiteContactGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> DirectorySiteContactGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> DirectorySiteContactGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -23388,7 +23384,7 @@ impl<'a, C, NC, A> DirectorySiteContactGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Directory site contact ID. - pub fn id(mut self, new_value: &str) -> DirectorySiteContactGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> DirectorySiteContactGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -23399,7 +23395,7 @@ impl<'a, C, NC, A> DirectorySiteContactGetCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DirectorySiteContactGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DirectorySiteContactGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -23420,7 +23416,7 @@ impl<'a, C, NC, A> DirectorySiteContactGetCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DirectorySiteContactGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DirectorySiteContactGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -23437,7 +23433,7 @@ impl<'a, C, NC, A> DirectorySiteContactGetCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DirectorySiteContactGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DirectorySiteContactGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -23482,10 +23478,10 @@ impl<'a, C, NC, A> DirectorySiteContactGetCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct DirectorySiteContactListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DirectorySiteContactListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _sort_order: Option, _sort_field: Option, @@ -23499,9 +23495,9 @@ pub struct DirectorySiteContactListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DirectorySiteContactListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DirectorySiteContactListCall<'a, C, A> {} -impl<'a, C, NC, A> DirectorySiteContactListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DirectorySiteContactListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -23662,7 +23658,7 @@ impl<'a, C, NC, A> DirectorySiteContactListCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> DirectorySiteContactListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> DirectorySiteContactListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -23670,7 +23666,7 @@ impl<'a, C, NC, A> DirectorySiteContactListCall<'a, C, NC, A> where NC: hyper::n /// /// /// Order of sorted results, default is ASCENDING. - pub fn sort_order(mut self, new_value: &str) -> DirectorySiteContactListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> DirectorySiteContactListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -23678,7 +23674,7 @@ impl<'a, C, NC, A> DirectorySiteContactListCall<'a, C, NC, A> where NC: hyper::n /// /// /// Field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> DirectorySiteContactListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> DirectorySiteContactListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -23686,7 +23682,7 @@ impl<'a, C, NC, A> DirectorySiteContactListCall<'a, C, NC, A> where NC: hyper::n /// /// /// Allows searching for objects by name, ID or email. Wildcards (*) are allowed. For example, "directory site contact*2015" will return objects with names like "directory site contact June 2015", "directory site contact April 2015", or simply "directory site contact 2015". Most of the searches also add wildcards implicitly at the start and the end of the search string. For example, a search string of "directory site contact" will match objects with name "my directory site contact", "directory site contact 2015", or simply "directory site contact". - pub fn search_string(mut self, new_value: &str) -> DirectorySiteContactListCall<'a, C, NC, A> { + pub fn search_string(mut self, new_value: &str) -> DirectorySiteContactListCall<'a, C, A> { self._search_string = Some(new_value.to_string()); self } @@ -23694,7 +23690,7 @@ impl<'a, C, NC, A> DirectorySiteContactListCall<'a, C, NC, A> where NC: hyper::n /// /// /// Value of the nextPageToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> DirectorySiteContactListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> DirectorySiteContactListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -23702,7 +23698,7 @@ impl<'a, C, NC, A> DirectorySiteContactListCall<'a, C, NC, A> where NC: hyper::n /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> DirectorySiteContactListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> DirectorySiteContactListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -23711,7 +23707,7 @@ impl<'a, C, NC, A> DirectorySiteContactListCall<'a, C, NC, A> where NC: hyper::n /// /// /// Select only directory site contacts with these IDs. - pub fn add_ids(mut self, new_value: &str) -> DirectorySiteContactListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> DirectorySiteContactListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -23720,7 +23716,7 @@ impl<'a, C, NC, A> DirectorySiteContactListCall<'a, C, NC, A> where NC: hyper::n /// /// /// Select only directory site contacts with these directory site IDs. This is a required field. - pub fn add_directory_site_ids(mut self, new_value: &str) -> DirectorySiteContactListCall<'a, C, NC, A> { + pub fn add_directory_site_ids(mut self, new_value: &str) -> DirectorySiteContactListCall<'a, C, A> { self._directory_site_ids.push(new_value.to_string()); self } @@ -23731,7 +23727,7 @@ impl<'a, C, NC, A> DirectorySiteContactListCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DirectorySiteContactListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DirectorySiteContactListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -23752,7 +23748,7 @@ impl<'a, C, NC, A> DirectorySiteContactListCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DirectorySiteContactListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DirectorySiteContactListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -23769,7 +23765,7 @@ impl<'a, C, NC, A> DirectorySiteContactListCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DirectorySiteContactListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DirectorySiteContactListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -23807,18 +23803,18 @@ impl<'a, C, NC, A> DirectorySiteContactListCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct UserProfileListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserProfileListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserProfileListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserProfileListCall<'a, C, A> {} -impl<'a, C, NC, A> UserProfileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserProfileListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -23926,7 +23922,7 @@ impl<'a, C, NC, A> UserProfileListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserProfileListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserProfileListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -23947,7 +23943,7 @@ impl<'a, C, NC, A> UserProfileListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserProfileListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserProfileListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -23964,7 +23960,7 @@ impl<'a, C, NC, A> UserProfileListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserProfileListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserProfileListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -24002,19 +23998,19 @@ impl<'a, C, NC, A> UserProfileListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct UserProfileGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserProfileGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserProfileGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserProfileGetCall<'a, C, A> {} -impl<'a, C, NC, A> UserProfileGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserProfileGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -24146,7 +24142,7 @@ impl<'a, C, NC, A> UserProfileGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The user profile ID. - pub fn profile_id(mut self, new_value: &str) -> UserProfileGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> UserProfileGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -24157,7 +24153,7 @@ impl<'a, C, NC, A> UserProfileGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserProfileGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserProfileGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -24178,7 +24174,7 @@ impl<'a, C, NC, A> UserProfileGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserProfileGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserProfileGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -24195,7 +24191,7 @@ impl<'a, C, NC, A> UserProfileGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserProfileGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserProfileGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -24239,10 +24235,10 @@ impl<'a, C, NC, A> UserProfileGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct AdPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Ad, _profile_id: String, _id: String, @@ -24251,9 +24247,9 @@ pub struct AdPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AdPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdPatchCall<'a, C, A> {} -impl<'a, C, NC, A> AdPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -24393,7 +24389,7 @@ impl<'a, C, NC, A> AdPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Ad) -> AdPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Ad) -> AdPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -24403,7 +24399,7 @@ impl<'a, C, NC, A> AdPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AdPatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AdPatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -24413,7 +24409,7 @@ impl<'a, C, NC, A> AdPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// Ad ID. - pub fn id(mut self, new_value: &str) -> AdPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> AdPatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -24424,7 +24420,7 @@ impl<'a, C, NC, A> AdPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -24445,7 +24441,7 @@ impl<'a, C, NC, A> AdPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -24462,7 +24458,7 @@ impl<'a, C, NC, A> AdPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AdPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AdPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -24506,10 +24502,10 @@ impl<'a, C, NC, A> AdPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct AdInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Ad, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -24517,9 +24513,9 @@ pub struct AdInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AdInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdInsertCall<'a, C, A> {} -impl<'a, C, NC, A> AdInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -24658,7 +24654,7 @@ impl<'a, C, NC, A> AdInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Ad) -> AdInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Ad) -> AdInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -24668,7 +24664,7 @@ impl<'a, C, NC, A> AdInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AdInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AdInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -24679,7 +24675,7 @@ impl<'a, C, NC, A> AdInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -24700,7 +24696,7 @@ impl<'a, C, NC, A> AdInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -24717,7 +24713,7 @@ impl<'a, C, NC, A> AdInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AdInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AdInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -24779,10 +24775,10 @@ impl<'a, C, NC, A> AdInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct AdListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _type_: Vec, _ssl_required: Option, @@ -24813,9 +24809,9 @@ pub struct AdListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AdListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdListCall<'a, C, A> {} -impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -25059,7 +25055,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AdListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AdListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -25068,7 +25064,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Select only ads with these types. - pub fn add_type(mut self, new_value: &str) -> AdListCall<'a, C, NC, A> { + pub fn add_type(mut self, new_value: &str) -> AdListCall<'a, C, A> { self._type_.push(new_value.to_string()); self } @@ -25076,7 +25072,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Select only ads that require SSL. - pub fn ssl_required(mut self, new_value: bool) -> AdListCall<'a, C, NC, A> { + pub fn ssl_required(mut self, new_value: bool) -> AdListCall<'a, C, A> { self._ssl_required = Some(new_value); self } @@ -25084,7 +25080,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Select only ads that are SSL-compliant. - pub fn ssl_compliant(mut self, new_value: bool) -> AdListCall<'a, C, NC, A> { + pub fn ssl_compliant(mut self, new_value: bool) -> AdListCall<'a, C, A> { self._ssl_compliant = Some(new_value); self } @@ -25092,7 +25088,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Order of sorted results, default is ASCENDING. - pub fn sort_order(mut self, new_value: &str) -> AdListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> AdListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -25100,7 +25096,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> AdListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> AdListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -25109,7 +25105,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Select only ads with these size IDs. - pub fn add_size_ids(mut self, new_value: &str) -> AdListCall<'a, C, NC, A> { + pub fn add_size_ids(mut self, new_value: &str) -> AdListCall<'a, C, A> { self._size_ids.push(new_value.to_string()); self } @@ -25117,7 +25113,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Allows searching for objects by name or ID. Wildcards (*) are allowed. For example, "ad*2015" will return objects with names like "ad June 2015", "ad April 2015", or simply "ad 2015". Most of the searches also add wildcards implicitly at the start and the end of the search string. For example, a search string of "ad" will match objects with name "my ad", "ad 2015", or simply "ad". - pub fn search_string(mut self, new_value: &str) -> AdListCall<'a, C, NC, A> { + pub fn search_string(mut self, new_value: &str) -> AdListCall<'a, C, A> { self._search_string = Some(new_value.to_string()); self } @@ -25126,7 +25122,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Select only ads whose list targeting expression use these remarketing list IDs. - pub fn add_remarketing_list_ids(mut self, new_value: &str) -> AdListCall<'a, C, NC, A> { + pub fn add_remarketing_list_ids(mut self, new_value: &str) -> AdListCall<'a, C, A> { self._remarketing_list_ids.push(new_value.to_string()); self } @@ -25135,7 +25131,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Select only ads with these placement IDs assigned. - pub fn add_placement_ids(mut self, new_value: &str) -> AdListCall<'a, C, NC, A> { + pub fn add_placement_ids(mut self, new_value: &str) -> AdListCall<'a, C, A> { self._placement_ids.push(new_value.to_string()); self } @@ -25143,7 +25139,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Value of the nextPageToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> AdListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AdListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -25151,7 +25147,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Select only ads with this event tag override ID. - pub fn overridden_event_tag_id(mut self, new_value: &str) -> AdListCall<'a, C, NC, A> { + pub fn overridden_event_tag_id(mut self, new_value: &str) -> AdListCall<'a, C, A> { self._overridden_event_tag_id = Some(new_value.to_string()); self } @@ -25159,7 +25155,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> AdListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AdListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -25168,7 +25164,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Select only ads with these landing page IDs. - pub fn add_landing_page_ids(mut self, new_value: &str) -> AdListCall<'a, C, NC, A> { + pub fn add_landing_page_ids(mut self, new_value: &str) -> AdListCall<'a, C, A> { self._landing_page_ids.push(new_value.to_string()); self } @@ -25177,7 +25173,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Select only ads with these IDs. - pub fn add_ids(mut self, new_value: &str) -> AdListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> AdListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -25185,7 +25181,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Select only dynamic click trackers. Applicable when type is AD_SERVING_CLICK_TRACKER. If true, select dynamic click trackers. If false, select static click trackers. Leave unset to select both. - pub fn dynamic_click_tracker(mut self, new_value: bool) -> AdListCall<'a, C, NC, A> { + pub fn dynamic_click_tracker(mut self, new_value: bool) -> AdListCall<'a, C, A> { self._dynamic_click_tracker = Some(new_value); self } @@ -25193,7 +25189,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Select only ads with the specified creativeType. - pub fn creative_type(mut self, new_value: &str) -> AdListCall<'a, C, NC, A> { + pub fn creative_type(mut self, new_value: &str) -> AdListCall<'a, C, A> { self._creative_type = Some(new_value.to_string()); self } @@ -25202,7 +25198,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Select only ads with these creative optimization configuration IDs. - pub fn add_creative_optimization_configuration_ids(mut self, new_value: &str) -> AdListCall<'a, C, NC, A> { + pub fn add_creative_optimization_configuration_ids(mut self, new_value: &str) -> AdListCall<'a, C, A> { self._creative_optimization_configuration_ids.push(new_value.to_string()); self } @@ -25211,7 +25207,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Select only ads with these creative IDs assigned. - pub fn add_creative_ids(mut self, new_value: &str) -> AdListCall<'a, C, NC, A> { + pub fn add_creative_ids(mut self, new_value: &str) -> AdListCall<'a, C, A> { self._creative_ids.push(new_value.to_string()); self } @@ -25219,7 +25215,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Select default ads with the specified compatibility. Applicable when type is AD_SERVING_DEFAULT_AD. WEB and WEB_INTERSTITIAL refer to rendering either on desktop or on mobile devices for regular or interstitial ads, respectively. APP and APP_INTERSTITIAL are for rendering in mobile apps. IN_STREAM_VIDEO refers to rendering an in-stream video ads developed with the VAST standard. - pub fn compatibility(mut self, new_value: &str) -> AdListCall<'a, C, NC, A> { + pub fn compatibility(mut self, new_value: &str) -> AdListCall<'a, C, A> { self._compatibility = Some(new_value.to_string()); self } @@ -25228,7 +25224,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Select only ads with these campaign IDs. - pub fn add_campaign_ids(mut self, new_value: &str) -> AdListCall<'a, C, NC, A> { + pub fn add_campaign_ids(mut self, new_value: &str) -> AdListCall<'a, C, A> { self._campaign_ids.push(new_value.to_string()); self } @@ -25237,7 +25233,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Select only ads with these audience segment IDs. - pub fn add_audience_segment_ids(mut self, new_value: &str) -> AdListCall<'a, C, NC, A> { + pub fn add_audience_segment_ids(mut self, new_value: &str) -> AdListCall<'a, C, A> { self._audience_segment_ids.push(new_value.to_string()); self } @@ -25245,7 +25241,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Select only archived ads. - pub fn archived(mut self, new_value: bool) -> AdListCall<'a, C, NC, A> { + pub fn archived(mut self, new_value: bool) -> AdListCall<'a, C, A> { self._archived = Some(new_value); self } @@ -25253,7 +25249,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Select only ads with this advertiser ID. - pub fn advertiser_id(mut self, new_value: &str) -> AdListCall<'a, C, NC, A> { + pub fn advertiser_id(mut self, new_value: &str) -> AdListCall<'a, C, A> { self._advertiser_id = Some(new_value.to_string()); self } @@ -25261,7 +25257,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Select only active ads. - pub fn active(mut self, new_value: bool) -> AdListCall<'a, C, NC, A> { + pub fn active(mut self, new_value: bool) -> AdListCall<'a, C, A> { self._active = Some(new_value); self } @@ -25272,7 +25268,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -25293,7 +25289,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -25310,7 +25306,7 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AdListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AdListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -25348,10 +25344,10 @@ impl<'a, C, NC, A> AdListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// .doit(); /// # } /// ``` -pub struct AdGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -25359,9 +25355,9 @@ pub struct AdGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AdGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdGetCall<'a, C, A> {} -impl<'a, C, NC, A> AdGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -25494,7 +25490,7 @@ impl<'a, C, NC, A> AdGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnecto /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AdGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AdGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -25504,7 +25500,7 @@ impl<'a, C, NC, A> AdGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnecto /// we provide this method for API completeness. /// /// Ad ID. - pub fn id(mut self, new_value: &str) -> AdGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> AdGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -25515,7 +25511,7 @@ impl<'a, C, NC, A> AdGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnecto /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -25536,7 +25532,7 @@ impl<'a, C, NC, A> AdGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnecto /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -25553,7 +25549,7 @@ impl<'a, C, NC, A> AdGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnecto /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AdGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AdGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -25597,10 +25593,10 @@ impl<'a, C, NC, A> AdGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnecto /// .doit(); /// # } /// ``` -pub struct AdUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Ad, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -25608,9 +25604,9 @@ pub struct AdUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AdUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AdUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -25749,7 +25745,7 @@ impl<'a, C, NC, A> AdUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Ad) -> AdUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Ad) -> AdUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -25759,7 +25755,7 @@ impl<'a, C, NC, A> AdUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AdUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AdUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -25770,7 +25766,7 @@ impl<'a, C, NC, A> AdUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -25791,7 +25787,7 @@ impl<'a, C, NC, A> AdUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -25808,7 +25804,7 @@ impl<'a, C, NC, A> AdUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AdUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AdUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -25846,10 +25842,10 @@ impl<'a, C, NC, A> AdUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct AccountPermissionGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountPermissionGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -25857,9 +25853,9 @@ pub struct AccountPermissionGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountPermissionGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountPermissionGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountPermissionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountPermissionGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -25992,7 +25988,7 @@ impl<'a, C, NC, A> AccountPermissionGetCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AccountPermissionGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AccountPermissionGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -26002,7 +25998,7 @@ impl<'a, C, NC, A> AccountPermissionGetCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Account permission ID. - pub fn id(mut self, new_value: &str) -> AccountPermissionGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> AccountPermissionGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -26013,7 +26009,7 @@ impl<'a, C, NC, A> AccountPermissionGetCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPermissionGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPermissionGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -26034,7 +26030,7 @@ impl<'a, C, NC, A> AccountPermissionGetCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountPermissionGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountPermissionGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -26051,7 +26047,7 @@ impl<'a, C, NC, A> AccountPermissionGetCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountPermissionGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountPermissionGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -26089,19 +26085,19 @@ impl<'a, C, NC, A> AccountPermissionGetCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct AccountPermissionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountPermissionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountPermissionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountPermissionListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountPermissionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountPermissionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -26233,7 +26229,7 @@ impl<'a, C, NC, A> AccountPermissionListCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AccountPermissionListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AccountPermissionListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -26244,7 +26240,7 @@ impl<'a, C, NC, A> AccountPermissionListCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPermissionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPermissionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -26265,7 +26261,7 @@ impl<'a, C, NC, A> AccountPermissionListCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountPermissionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountPermissionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -26282,7 +26278,7 @@ impl<'a, C, NC, A> AccountPermissionListCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountPermissionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountPermissionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -26320,19 +26316,19 @@ impl<'a, C, NC, A> AccountPermissionListCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct ConnectionTypeListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ConnectionTypeListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ConnectionTypeListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ConnectionTypeListCall<'a, C, A> {} -impl<'a, C, NC, A> ConnectionTypeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ConnectionTypeListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -26464,7 +26460,7 @@ impl<'a, C, NC, A> ConnectionTypeListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> ConnectionTypeListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ConnectionTypeListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -26475,7 +26471,7 @@ impl<'a, C, NC, A> ConnectionTypeListCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ConnectionTypeListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ConnectionTypeListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -26496,7 +26492,7 @@ impl<'a, C, NC, A> ConnectionTypeListCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ConnectionTypeListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ConnectionTypeListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -26513,7 +26509,7 @@ impl<'a, C, NC, A> ConnectionTypeListCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ConnectionTypeListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ConnectionTypeListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -26551,10 +26547,10 @@ impl<'a, C, NC, A> ConnectionTypeListCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct AdvertiserGroupGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdvertiserGroupGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -26562,9 +26558,9 @@ pub struct AdvertiserGroupGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AdvertiserGroupGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdvertiserGroupGetCall<'a, C, A> {} -impl<'a, C, NC, A> AdvertiserGroupGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdvertiserGroupGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -26697,7 +26693,7 @@ impl<'a, C, NC, A> AdvertiserGroupGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AdvertiserGroupGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AdvertiserGroupGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -26707,7 +26703,7 @@ impl<'a, C, NC, A> AdvertiserGroupGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Advertiser group ID. - pub fn id(mut self, new_value: &str) -> AdvertiserGroupGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> AdvertiserGroupGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -26718,7 +26714,7 @@ impl<'a, C, NC, A> AdvertiserGroupGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserGroupGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserGroupGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -26739,7 +26735,7 @@ impl<'a, C, NC, A> AdvertiserGroupGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdvertiserGroupGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdvertiserGroupGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -26756,7 +26752,7 @@ impl<'a, C, NC, A> AdvertiserGroupGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AdvertiserGroupGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AdvertiserGroupGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -26800,10 +26796,10 @@ impl<'a, C, NC, A> AdvertiserGroupGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct AdvertiserGroupListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdvertiserGroupListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _sort_order: Option, _sort_field: Option, @@ -26816,9 +26812,9 @@ pub struct AdvertiserGroupListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AdvertiserGroupListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdvertiserGroupListCall<'a, C, A> {} -impl<'a, C, NC, A> AdvertiserGroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdvertiserGroupListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -26972,7 +26968,7 @@ impl<'a, C, NC, A> AdvertiserGroupListCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AdvertiserGroupListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AdvertiserGroupListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -26980,7 +26976,7 @@ impl<'a, C, NC, A> AdvertiserGroupListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Order of sorted results, default is ASCENDING. - pub fn sort_order(mut self, new_value: &str) -> AdvertiserGroupListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> AdvertiserGroupListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -26988,7 +26984,7 @@ impl<'a, C, NC, A> AdvertiserGroupListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> AdvertiserGroupListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> AdvertiserGroupListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -26996,7 +26992,7 @@ impl<'a, C, NC, A> AdvertiserGroupListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Allows searching for objects by name or ID. Wildcards (*) are allowed. For example, "advertiser*2015" will return objects with names like "advertiser group June 2015", "advertiser group April 2015", or simply "advertiser group 2015". Most of the searches also add wildcards implicitly at the start and the end of the search string. For example, a search string of "advertisergroup" will match objects with name "my advertisergroup", "advertisergroup 2015", or simply "advertisergroup". - pub fn search_string(mut self, new_value: &str) -> AdvertiserGroupListCall<'a, C, NC, A> { + pub fn search_string(mut self, new_value: &str) -> AdvertiserGroupListCall<'a, C, A> { self._search_string = Some(new_value.to_string()); self } @@ -27004,7 +27000,7 @@ impl<'a, C, NC, A> AdvertiserGroupListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Value of the nextPageToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> AdvertiserGroupListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AdvertiserGroupListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -27012,7 +27008,7 @@ impl<'a, C, NC, A> AdvertiserGroupListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> AdvertiserGroupListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AdvertiserGroupListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -27021,7 +27017,7 @@ impl<'a, C, NC, A> AdvertiserGroupListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Select only advertiser groups with these IDs. - pub fn add_ids(mut self, new_value: &str) -> AdvertiserGroupListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> AdvertiserGroupListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -27032,7 +27028,7 @@ impl<'a, C, NC, A> AdvertiserGroupListCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserGroupListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserGroupListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -27053,7 +27049,7 @@ impl<'a, C, NC, A> AdvertiserGroupListCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdvertiserGroupListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdvertiserGroupListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -27070,7 +27066,7 @@ impl<'a, C, NC, A> AdvertiserGroupListCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AdvertiserGroupListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AdvertiserGroupListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -27114,10 +27110,10 @@ impl<'a, C, NC, A> AdvertiserGroupListCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct AdvertiserGroupInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdvertiserGroupInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: AdvertiserGroup, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -27125,9 +27121,9 @@ pub struct AdvertiserGroupInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AdvertiserGroupInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdvertiserGroupInsertCall<'a, C, A> {} -impl<'a, C, NC, A> AdvertiserGroupInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdvertiserGroupInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -27266,7 +27262,7 @@ impl<'a, C, NC, A> AdvertiserGroupInsertCall<'a, C, NC, A> where NC: hyper::net: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AdvertiserGroup) -> AdvertiserGroupInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AdvertiserGroup) -> AdvertiserGroupInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -27276,7 +27272,7 @@ impl<'a, C, NC, A> AdvertiserGroupInsertCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AdvertiserGroupInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AdvertiserGroupInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -27287,7 +27283,7 @@ impl<'a, C, NC, A> AdvertiserGroupInsertCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserGroupInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserGroupInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -27308,7 +27304,7 @@ impl<'a, C, NC, A> AdvertiserGroupInsertCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdvertiserGroupInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdvertiserGroupInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -27325,7 +27321,7 @@ impl<'a, C, NC, A> AdvertiserGroupInsertCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AdvertiserGroupInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AdvertiserGroupInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -27369,10 +27365,10 @@ impl<'a, C, NC, A> AdvertiserGroupInsertCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct AdvertiserGroupUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdvertiserGroupUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: AdvertiserGroup, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -27380,9 +27376,9 @@ pub struct AdvertiserGroupUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AdvertiserGroupUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdvertiserGroupUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AdvertiserGroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdvertiserGroupUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -27521,7 +27517,7 @@ impl<'a, C, NC, A> AdvertiserGroupUpdateCall<'a, C, NC, A> where NC: hyper::net: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AdvertiserGroup) -> AdvertiserGroupUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AdvertiserGroup) -> AdvertiserGroupUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -27531,7 +27527,7 @@ impl<'a, C, NC, A> AdvertiserGroupUpdateCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AdvertiserGroupUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AdvertiserGroupUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -27542,7 +27538,7 @@ impl<'a, C, NC, A> AdvertiserGroupUpdateCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserGroupUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserGroupUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -27563,7 +27559,7 @@ impl<'a, C, NC, A> AdvertiserGroupUpdateCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdvertiserGroupUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdvertiserGroupUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -27580,7 +27576,7 @@ impl<'a, C, NC, A> AdvertiserGroupUpdateCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AdvertiserGroupUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AdvertiserGroupUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -27624,10 +27620,10 @@ impl<'a, C, NC, A> AdvertiserGroupUpdateCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct AdvertiserGroupPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdvertiserGroupPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: AdvertiserGroup, _profile_id: String, _id: String, @@ -27636,9 +27632,9 @@ pub struct AdvertiserGroupPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AdvertiserGroupPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdvertiserGroupPatchCall<'a, C, A> {} -impl<'a, C, NC, A> AdvertiserGroupPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdvertiserGroupPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -27778,7 +27774,7 @@ impl<'a, C, NC, A> AdvertiserGroupPatchCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AdvertiserGroup) -> AdvertiserGroupPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AdvertiserGroup) -> AdvertiserGroupPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -27788,7 +27784,7 @@ impl<'a, C, NC, A> AdvertiserGroupPatchCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AdvertiserGroupPatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AdvertiserGroupPatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -27798,7 +27794,7 @@ impl<'a, C, NC, A> AdvertiserGroupPatchCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Advertiser group ID. - pub fn id(mut self, new_value: &str) -> AdvertiserGroupPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> AdvertiserGroupPatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -27809,7 +27805,7 @@ impl<'a, C, NC, A> AdvertiserGroupPatchCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserGroupPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserGroupPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -27830,7 +27826,7 @@ impl<'a, C, NC, A> AdvertiserGroupPatchCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdvertiserGroupPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdvertiserGroupPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -27847,7 +27843,7 @@ impl<'a, C, NC, A> AdvertiserGroupPatchCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AdvertiserGroupPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AdvertiserGroupPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -27885,10 +27881,10 @@ impl<'a, C, NC, A> AdvertiserGroupPatchCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct AdvertiserGroupDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdvertiserGroupDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -27896,9 +27892,9 @@ pub struct AdvertiserGroupDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AdvertiserGroupDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdvertiserGroupDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> AdvertiserGroupDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdvertiserGroupDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -28020,7 +28016,7 @@ impl<'a, C, NC, A> AdvertiserGroupDeleteCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AdvertiserGroupDeleteCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AdvertiserGroupDeleteCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -28030,7 +28026,7 @@ impl<'a, C, NC, A> AdvertiserGroupDeleteCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Advertiser group ID. - pub fn id(mut self, new_value: &str) -> AdvertiserGroupDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> AdvertiserGroupDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -28041,7 +28037,7 @@ impl<'a, C, NC, A> AdvertiserGroupDeleteCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserGroupDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserGroupDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -28062,7 +28058,7 @@ impl<'a, C, NC, A> AdvertiserGroupDeleteCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdvertiserGroupDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdvertiserGroupDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -28079,7 +28075,7 @@ impl<'a, C, NC, A> AdvertiserGroupDeleteCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AdvertiserGroupDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AdvertiserGroupDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -28123,10 +28119,10 @@ impl<'a, C, NC, A> AdvertiserGroupDeleteCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct SiteInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SiteInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Site, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -28134,9 +28130,9 @@ pub struct SiteInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SiteInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SiteInsertCall<'a, C, A> {} -impl<'a, C, NC, A> SiteInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SiteInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -28275,7 +28271,7 @@ impl<'a, C, NC, A> SiteInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Site) -> SiteInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Site) -> SiteInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -28285,7 +28281,7 @@ impl<'a, C, NC, A> SiteInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> SiteInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> SiteInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -28296,7 +28292,7 @@ impl<'a, C, NC, A> SiteInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SiteInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SiteInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -28317,7 +28313,7 @@ impl<'a, C, NC, A> SiteInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SiteInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SiteInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -28334,7 +28330,7 @@ impl<'a, C, NC, A> SiteInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SiteInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SiteInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -28372,10 +28368,10 @@ impl<'a, C, NC, A> SiteInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct SiteGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SiteGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -28383,9 +28379,9 @@ pub struct SiteGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SiteGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SiteGetCall<'a, C, A> {} -impl<'a, C, NC, A> SiteGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SiteGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -28518,7 +28514,7 @@ impl<'a, C, NC, A> SiteGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> SiteGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> SiteGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -28528,7 +28524,7 @@ impl<'a, C, NC, A> SiteGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// Site ID. - pub fn id(mut self, new_value: &str) -> SiteGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> SiteGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -28539,7 +28535,7 @@ impl<'a, C, NC, A> SiteGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SiteGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SiteGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -28560,7 +28556,7 @@ impl<'a, C, NC, A> SiteGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SiteGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SiteGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -28577,7 +28573,7 @@ impl<'a, C, NC, A> SiteGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SiteGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SiteGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -28630,10 +28626,10 @@ impl<'a, C, NC, A> SiteGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct SiteListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SiteListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _unmapped_site: Option, _subaccount_id: Option, @@ -28655,9 +28651,9 @@ pub struct SiteListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SiteListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SiteListCall<'a, C, A> {} -impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SiteListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -28846,7 +28842,7 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> SiteListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> SiteListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -28854,7 +28850,7 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Select only sites that have not been mapped to a directory site. - pub fn unmapped_site(mut self, new_value: bool) -> SiteListCall<'a, C, NC, A> { + pub fn unmapped_site(mut self, new_value: bool) -> SiteListCall<'a, C, A> { self._unmapped_site = Some(new_value); self } @@ -28862,7 +28858,7 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Select only sites with this subaccount ID. - pub fn subaccount_id(mut self, new_value: &str) -> SiteListCall<'a, C, NC, A> { + pub fn subaccount_id(mut self, new_value: &str) -> SiteListCall<'a, C, A> { self._subaccount_id = Some(new_value.to_string()); self } @@ -28870,7 +28866,7 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Order of sorted results, default is ASCENDING. - pub fn sort_order(mut self, new_value: &str) -> SiteListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> SiteListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -28878,7 +28874,7 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> SiteListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> SiteListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -28886,7 +28882,7 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Allows searching for objects by name, ID or keyName. Wildcards (*) are allowed. For example, "site*2015" will return objects with names like "site June 2015", "site April 2015", or simply "site 2015". Most of the searches also add wildcards implicitly at the start and the end of the search string. For example, a search string of "site" will match objects with name "my site", "site 2015", or simply "site". - pub fn search_string(mut self, new_value: &str) -> SiteListCall<'a, C, NC, A> { + pub fn search_string(mut self, new_value: &str) -> SiteListCall<'a, C, A> { self._search_string = Some(new_value.to_string()); self } @@ -28894,7 +28890,7 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Value of the nextPageToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> SiteListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> SiteListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -28902,7 +28898,7 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> SiteListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> SiteListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -28911,7 +28907,7 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Select only sites with these IDs. - pub fn add_ids(mut self, new_value: &str) -> SiteListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> SiteListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -28920,7 +28916,7 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Select only sites with these directory site IDs. - pub fn add_directory_site_ids(mut self, new_value: &str) -> SiteListCall<'a, C, NC, A> { + pub fn add_directory_site_ids(mut self, new_value: &str) -> SiteListCall<'a, C, A> { self._directory_site_ids.push(new_value.to_string()); self } @@ -28929,7 +28925,7 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Select only sites with these campaign IDs. - pub fn add_campaign_ids(mut self, new_value: &str) -> SiteListCall<'a, C, NC, A> { + pub fn add_campaign_ids(mut self, new_value: &str) -> SiteListCall<'a, C, A> { self._campaign_ids.push(new_value.to_string()); self } @@ -28937,7 +28933,7 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Select only approved sites. - pub fn approved(mut self, new_value: bool) -> SiteListCall<'a, C, NC, A> { + pub fn approved(mut self, new_value: bool) -> SiteListCall<'a, C, A> { self._approved = Some(new_value); self } @@ -28945,7 +28941,7 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Select only AdWords sites. - pub fn ad_words_site(mut self, new_value: bool) -> SiteListCall<'a, C, NC, A> { + pub fn ad_words_site(mut self, new_value: bool) -> SiteListCall<'a, C, A> { self._ad_words_site = Some(new_value); self } @@ -28953,7 +28949,7 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Select only sites that accept publisher paid placements. - pub fn accepts_publisher_paid_placements(mut self, new_value: bool) -> SiteListCall<'a, C, NC, A> { + pub fn accepts_publisher_paid_placements(mut self, new_value: bool) -> SiteListCall<'a, C, A> { self._accepts_publisher_paid_placements = Some(new_value); self } @@ -28961,7 +28957,7 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// This search filter is no longer supported and will have no effect on the results returned. - pub fn accepts_interstitial_placements(mut self, new_value: bool) -> SiteListCall<'a, C, NC, A> { + pub fn accepts_interstitial_placements(mut self, new_value: bool) -> SiteListCall<'a, C, A> { self._accepts_interstitial_placements = Some(new_value); self } @@ -28969,7 +28965,7 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// This search filter is no longer supported and will have no effect on the results returned. - pub fn accepts_in_stream_video_placements(mut self, new_value: bool) -> SiteListCall<'a, C, NC, A> { + pub fn accepts_in_stream_video_placements(mut self, new_value: bool) -> SiteListCall<'a, C, A> { self._accepts_in_stream_video_placements = Some(new_value); self } @@ -28980,7 +28976,7 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SiteListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SiteListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -29001,7 +28997,7 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SiteListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SiteListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -29018,7 +29014,7 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SiteListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SiteListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -29062,10 +29058,10 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct SiteUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SiteUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Site, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -29073,9 +29069,9 @@ pub struct SiteUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SiteUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SiteUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> SiteUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SiteUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -29214,7 +29210,7 @@ impl<'a, C, NC, A> SiteUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Site) -> SiteUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Site) -> SiteUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -29224,7 +29220,7 @@ impl<'a, C, NC, A> SiteUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> SiteUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> SiteUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -29235,7 +29231,7 @@ impl<'a, C, NC, A> SiteUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SiteUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SiteUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -29256,7 +29252,7 @@ impl<'a, C, NC, A> SiteUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SiteUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SiteUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -29273,7 +29269,7 @@ impl<'a, C, NC, A> SiteUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SiteUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SiteUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -29317,10 +29313,10 @@ impl<'a, C, NC, A> SiteUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct SitePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SitePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Site, _profile_id: String, _id: String, @@ -29329,9 +29325,9 @@ pub struct SitePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SitePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SitePatchCall<'a, C, A> {} -impl<'a, C, NC, A> SitePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SitePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -29471,7 +29467,7 @@ impl<'a, C, NC, A> SitePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Site) -> SitePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Site) -> SitePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -29481,7 +29477,7 @@ impl<'a, C, NC, A> SitePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> SitePatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> SitePatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -29491,7 +29487,7 @@ impl<'a, C, NC, A> SitePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Site ID. - pub fn id(mut self, new_value: &str) -> SitePatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> SitePatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -29502,7 +29498,7 @@ impl<'a, C, NC, A> SitePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SitePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SitePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -29523,7 +29519,7 @@ impl<'a, C, NC, A> SitePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SitePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SitePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -29540,7 +29536,7 @@ impl<'a, C, NC, A> SitePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SitePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SitePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -29578,10 +29574,10 @@ impl<'a, C, NC, A> SitePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct FloodlightActivityGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FloodlightActivityGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -29589,9 +29585,9 @@ pub struct FloodlightActivityGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FloodlightActivityGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FloodlightActivityGetCall<'a, C, A> {} -impl<'a, C, NC, A> FloodlightActivityGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FloodlightActivityGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -29724,7 +29720,7 @@ impl<'a, C, NC, A> FloodlightActivityGetCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -29734,7 +29730,7 @@ impl<'a, C, NC, A> FloodlightActivityGetCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Floodlight activity ID. - pub fn id(mut self, new_value: &str) -> FloodlightActivityGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> FloodlightActivityGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -29745,7 +29741,7 @@ impl<'a, C, NC, A> FloodlightActivityGetCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -29766,7 +29762,7 @@ impl<'a, C, NC, A> FloodlightActivityGetCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FloodlightActivityGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FloodlightActivityGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -29783,7 +29779,7 @@ impl<'a, C, NC, A> FloodlightActivityGetCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FloodlightActivityGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FloodlightActivityGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -29834,10 +29830,10 @@ impl<'a, C, NC, A> FloodlightActivityGetCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct FloodlightActivityListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FloodlightActivityListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _tag_string: Option, _sort_order: Option, @@ -29857,9 +29853,9 @@ pub struct FloodlightActivityListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FloodlightActivityListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FloodlightActivityListCall<'a, C, A> {} -impl<'a, C, NC, A> FloodlightActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FloodlightActivityListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -30038,7 +30034,7 @@ impl<'a, C, NC, A> FloodlightActivityListCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -30046,7 +30042,7 @@ impl<'a, C, NC, A> FloodlightActivityListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Select only floodlight activities with the specified tag string. - pub fn tag_string(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, NC, A> { + pub fn tag_string(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, A> { self._tag_string = Some(new_value.to_string()); self } @@ -30054,7 +30050,7 @@ impl<'a, C, NC, A> FloodlightActivityListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Order of sorted results, default is ASCENDING. - pub fn sort_order(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -30062,7 +30058,7 @@ impl<'a, C, NC, A> FloodlightActivityListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -30070,7 +30066,7 @@ impl<'a, C, NC, A> FloodlightActivityListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Allows searching for objects by name or ID. Wildcards (*) are allowed. For example, "floodlightactivity*2015" will return objects with names like "floodlightactivity June 2015", "floodlightactivity April 2015", or simply "floodlightactivity 2015". Most of the searches also add wildcards implicitly at the start and the end of the search string. For example, a search string of "floodlightactivity" will match objects with name "my floodlightactivity activity", "floodlightactivity 2015", or simply "floodlightactivity". - pub fn search_string(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, NC, A> { + pub fn search_string(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, A> { self._search_string = Some(new_value.to_string()); self } @@ -30078,7 +30074,7 @@ impl<'a, C, NC, A> FloodlightActivityListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Value of the nextPageToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -30086,7 +30082,7 @@ impl<'a, C, NC, A> FloodlightActivityListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> FloodlightActivityListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> FloodlightActivityListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -30095,7 +30091,7 @@ impl<'a, C, NC, A> FloodlightActivityListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Select only floodlight activities with the specified IDs. Must specify either ids, advertiserId, or floodlightConfigurationId for a non-empty result. - pub fn add_ids(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -30103,7 +30099,7 @@ impl<'a, C, NC, A> FloodlightActivityListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Select only floodlight activities for the specified floodlight configuration ID. Must specify either ids, advertiserId, or floodlightConfigurationId for a non-empty result. - pub fn floodlight_configuration_id(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, NC, A> { + pub fn floodlight_configuration_id(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, A> { self._floodlight_configuration_id = Some(new_value.to_string()); self } @@ -30111,7 +30107,7 @@ impl<'a, C, NC, A> FloodlightActivityListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Select only floodlight activities with the specified floodlight activity group type. - pub fn floodlight_activity_group_type(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, NC, A> { + pub fn floodlight_activity_group_type(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, A> { self._floodlight_activity_group_type = Some(new_value.to_string()); self } @@ -30119,7 +30115,7 @@ impl<'a, C, NC, A> FloodlightActivityListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Select only floodlight activities with the specified floodlight activity group tag string. - pub fn floodlight_activity_group_tag_string(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, NC, A> { + pub fn floodlight_activity_group_tag_string(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, A> { self._floodlight_activity_group_tag_string = Some(new_value.to_string()); self } @@ -30127,7 +30123,7 @@ impl<'a, C, NC, A> FloodlightActivityListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Select only floodlight activities with the specified floodlight activity group name. - pub fn floodlight_activity_group_name(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, NC, A> { + pub fn floodlight_activity_group_name(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, A> { self._floodlight_activity_group_name = Some(new_value.to_string()); self } @@ -30136,7 +30132,7 @@ impl<'a, C, NC, A> FloodlightActivityListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Select only floodlight activities with the specified floodlight activity group IDs. - pub fn add_floodlight_activity_group_ids(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, NC, A> { + pub fn add_floodlight_activity_group_ids(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, A> { self._floodlight_activity_group_ids.push(new_value.to_string()); self } @@ -30144,7 +30140,7 @@ impl<'a, C, NC, A> FloodlightActivityListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Select only floodlight activities for the specified advertiser ID. Must specify either ids, advertiserId, or floodlightConfigurationId for a non-empty result. - pub fn advertiser_id(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, NC, A> { + pub fn advertiser_id(mut self, new_value: &str) -> FloodlightActivityListCall<'a, C, A> { self._advertiser_id = Some(new_value.to_string()); self } @@ -30155,7 +30151,7 @@ impl<'a, C, NC, A> FloodlightActivityListCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -30176,7 +30172,7 @@ impl<'a, C, NC, A> FloodlightActivityListCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FloodlightActivityListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FloodlightActivityListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -30193,7 +30189,7 @@ impl<'a, C, NC, A> FloodlightActivityListCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FloodlightActivityListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FloodlightActivityListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -30237,10 +30233,10 @@ impl<'a, C, NC, A> FloodlightActivityListCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct FloodlightActivityInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FloodlightActivityInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: FloodlightActivity, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -30248,9 +30244,9 @@ pub struct FloodlightActivityInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FloodlightActivityInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FloodlightActivityInsertCall<'a, C, A> {} -impl<'a, C, NC, A> FloodlightActivityInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FloodlightActivityInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -30389,7 +30385,7 @@ impl<'a, C, NC, A> FloodlightActivityInsertCall<'a, C, NC, A> where NC: hyper::n /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &FloodlightActivity) -> FloodlightActivityInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &FloodlightActivity) -> FloodlightActivityInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -30399,7 +30395,7 @@ impl<'a, C, NC, A> FloodlightActivityInsertCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -30410,7 +30406,7 @@ impl<'a, C, NC, A> FloodlightActivityInsertCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -30431,7 +30427,7 @@ impl<'a, C, NC, A> FloodlightActivityInsertCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FloodlightActivityInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FloodlightActivityInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -30448,7 +30444,7 @@ impl<'a, C, NC, A> FloodlightActivityInsertCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FloodlightActivityInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FloodlightActivityInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -30486,10 +30482,10 @@ impl<'a, C, NC, A> FloodlightActivityInsertCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct FloodlightActivityDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FloodlightActivityDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -30497,9 +30493,9 @@ pub struct FloodlightActivityDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FloodlightActivityDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FloodlightActivityDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> FloodlightActivityDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FloodlightActivityDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -30621,7 +30617,7 @@ impl<'a, C, NC, A> FloodlightActivityDeleteCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityDeleteCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityDeleteCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -30631,7 +30627,7 @@ impl<'a, C, NC, A> FloodlightActivityDeleteCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Floodlight activity ID. - pub fn id(mut self, new_value: &str) -> FloodlightActivityDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> FloodlightActivityDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -30642,7 +30638,7 @@ impl<'a, C, NC, A> FloodlightActivityDeleteCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -30663,7 +30659,7 @@ impl<'a, C, NC, A> FloodlightActivityDeleteCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FloodlightActivityDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FloodlightActivityDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -30680,7 +30676,7 @@ impl<'a, C, NC, A> FloodlightActivityDeleteCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FloodlightActivityDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FloodlightActivityDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -30724,10 +30720,10 @@ impl<'a, C, NC, A> FloodlightActivityDeleteCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct FloodlightActivityPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FloodlightActivityPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: FloodlightActivity, _profile_id: String, _id: String, @@ -30736,9 +30732,9 @@ pub struct FloodlightActivityPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FloodlightActivityPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FloodlightActivityPatchCall<'a, C, A> {} -impl<'a, C, NC, A> FloodlightActivityPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FloodlightActivityPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -30878,7 +30874,7 @@ impl<'a, C, NC, A> FloodlightActivityPatchCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &FloodlightActivity) -> FloodlightActivityPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &FloodlightActivity) -> FloodlightActivityPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -30888,7 +30884,7 @@ impl<'a, C, NC, A> FloodlightActivityPatchCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityPatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityPatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -30898,7 +30894,7 @@ impl<'a, C, NC, A> FloodlightActivityPatchCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Floodlight activity ID. - pub fn id(mut self, new_value: &str) -> FloodlightActivityPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> FloodlightActivityPatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -30909,7 +30905,7 @@ impl<'a, C, NC, A> FloodlightActivityPatchCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -30930,7 +30926,7 @@ impl<'a, C, NC, A> FloodlightActivityPatchCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FloodlightActivityPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FloodlightActivityPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -30947,7 +30943,7 @@ impl<'a, C, NC, A> FloodlightActivityPatchCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FloodlightActivityPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FloodlightActivityPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -30986,10 +30982,10 @@ impl<'a, C, NC, A> FloodlightActivityPatchCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct FloodlightActivityGeneratetagCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FloodlightActivityGeneratetagCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _floodlight_activity_id: Option, _delegate: Option<&'a mut Delegate>, @@ -30997,9 +30993,9 @@ pub struct FloodlightActivityGeneratetagCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FloodlightActivityGeneratetagCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FloodlightActivityGeneratetagCall<'a, C, A> {} -impl<'a, C, NC, A> FloodlightActivityGeneratetagCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FloodlightActivityGeneratetagCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -31134,7 +31130,7 @@ impl<'a, C, NC, A> FloodlightActivityGeneratetagCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityGeneratetagCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityGeneratetagCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -31142,7 +31138,7 @@ impl<'a, C, NC, A> FloodlightActivityGeneratetagCall<'a, C, NC, A> where NC: hyp /// /// /// Floodlight activity ID for which we want to generate a tag. - pub fn floodlight_activity_id(mut self, new_value: &str) -> FloodlightActivityGeneratetagCall<'a, C, NC, A> { + pub fn floodlight_activity_id(mut self, new_value: &str) -> FloodlightActivityGeneratetagCall<'a, C, A> { self._floodlight_activity_id = Some(new_value.to_string()); self } @@ -31153,7 +31149,7 @@ impl<'a, C, NC, A> FloodlightActivityGeneratetagCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityGeneratetagCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityGeneratetagCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -31174,7 +31170,7 @@ impl<'a, C, NC, A> FloodlightActivityGeneratetagCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FloodlightActivityGeneratetagCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FloodlightActivityGeneratetagCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -31191,7 +31187,7 @@ impl<'a, C, NC, A> FloodlightActivityGeneratetagCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FloodlightActivityGeneratetagCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FloodlightActivityGeneratetagCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -31235,10 +31231,10 @@ impl<'a, C, NC, A> FloodlightActivityGeneratetagCall<'a, C, NC, A> where NC: hyp /// .doit(); /// # } /// ``` -pub struct FloodlightActivityUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FloodlightActivityUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: FloodlightActivity, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -31246,9 +31242,9 @@ pub struct FloodlightActivityUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FloodlightActivityUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FloodlightActivityUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> FloodlightActivityUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FloodlightActivityUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -31387,7 +31383,7 @@ impl<'a, C, NC, A> FloodlightActivityUpdateCall<'a, C, NC, A> where NC: hyper::n /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &FloodlightActivity) -> FloodlightActivityUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &FloodlightActivity) -> FloodlightActivityUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -31397,7 +31393,7 @@ impl<'a, C, NC, A> FloodlightActivityUpdateCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> FloodlightActivityUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -31408,7 +31404,7 @@ impl<'a, C, NC, A> FloodlightActivityUpdateCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightActivityUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -31429,7 +31425,7 @@ impl<'a, C, NC, A> FloodlightActivityUpdateCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FloodlightActivityUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FloodlightActivityUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -31446,7 +31442,7 @@ impl<'a, C, NC, A> FloodlightActivityUpdateCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FloodlightActivityUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FloodlightActivityUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -31484,19 +31480,19 @@ impl<'a, C, NC, A> FloodlightActivityUpdateCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct RegionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RegionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RegionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RegionListCall<'a, C, A> {} -impl<'a, C, NC, A> RegionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RegionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -31628,7 +31624,7 @@ impl<'a, C, NC, A> RegionListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> RegionListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> RegionListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -31639,7 +31635,7 @@ impl<'a, C, NC, A> RegionListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RegionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RegionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -31660,7 +31656,7 @@ impl<'a, C, NC, A> RegionListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RegionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RegionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -31677,7 +31673,7 @@ impl<'a, C, NC, A> RegionListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RegionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RegionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -31721,10 +31717,10 @@ impl<'a, C, NC, A> RegionListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct CreativeGroupInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeGroupInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: CreativeGroup, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -31732,9 +31728,9 @@ pub struct CreativeGroupInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeGroupInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeGroupInsertCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeGroupInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeGroupInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -31873,7 +31869,7 @@ impl<'a, C, NC, A> CreativeGroupInsertCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CreativeGroup) -> CreativeGroupInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CreativeGroup) -> CreativeGroupInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -31883,7 +31879,7 @@ impl<'a, C, NC, A> CreativeGroupInsertCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CreativeGroupInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CreativeGroupInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -31894,7 +31890,7 @@ impl<'a, C, NC, A> CreativeGroupInsertCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeGroupInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeGroupInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -31915,7 +31911,7 @@ impl<'a, C, NC, A> CreativeGroupInsertCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeGroupInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeGroupInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -31932,7 +31928,7 @@ impl<'a, C, NC, A> CreativeGroupInsertCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeGroupInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeGroupInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -31970,10 +31966,10 @@ impl<'a, C, NC, A> CreativeGroupInsertCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct CreativeGroupGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeGroupGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -31981,9 +31977,9 @@ pub struct CreativeGroupGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeGroupGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeGroupGetCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeGroupGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeGroupGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -32116,7 +32112,7 @@ impl<'a, C, NC, A> CreativeGroupGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CreativeGroupGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CreativeGroupGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -32126,7 +32122,7 @@ impl<'a, C, NC, A> CreativeGroupGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Creative group ID. - pub fn id(mut self, new_value: &str) -> CreativeGroupGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> CreativeGroupGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -32137,7 +32133,7 @@ impl<'a, C, NC, A> CreativeGroupGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeGroupGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeGroupGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -32158,7 +32154,7 @@ impl<'a, C, NC, A> CreativeGroupGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeGroupGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeGroupGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -32175,7 +32171,7 @@ impl<'a, C, NC, A> CreativeGroupGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeGroupGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeGroupGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -32219,10 +32215,10 @@ impl<'a, C, NC, A> CreativeGroupGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct CreativeGroupUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeGroupUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: CreativeGroup, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -32230,9 +32226,9 @@ pub struct CreativeGroupUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeGroupUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeGroupUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeGroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeGroupUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -32371,7 +32367,7 @@ impl<'a, C, NC, A> CreativeGroupUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CreativeGroup) -> CreativeGroupUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CreativeGroup) -> CreativeGroupUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -32381,7 +32377,7 @@ impl<'a, C, NC, A> CreativeGroupUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CreativeGroupUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CreativeGroupUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -32392,7 +32388,7 @@ impl<'a, C, NC, A> CreativeGroupUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeGroupUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeGroupUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -32413,7 +32409,7 @@ impl<'a, C, NC, A> CreativeGroupUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeGroupUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeGroupUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -32430,7 +32426,7 @@ impl<'a, C, NC, A> CreativeGroupUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeGroupUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeGroupUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -32476,10 +32472,10 @@ impl<'a, C, NC, A> CreativeGroupUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct CreativeGroupListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeGroupListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _sort_order: Option, _sort_field: Option, @@ -32494,9 +32490,9 @@ pub struct CreativeGroupListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeGroupListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeGroupListCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeGroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeGroupListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -32660,7 +32656,7 @@ impl<'a, C, NC, A> CreativeGroupListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CreativeGroupListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CreativeGroupListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -32668,7 +32664,7 @@ impl<'a, C, NC, A> CreativeGroupListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Order of sorted results, default is ASCENDING. - pub fn sort_order(mut self, new_value: &str) -> CreativeGroupListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> CreativeGroupListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -32676,7 +32672,7 @@ impl<'a, C, NC, A> CreativeGroupListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> CreativeGroupListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> CreativeGroupListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -32684,7 +32680,7 @@ impl<'a, C, NC, A> CreativeGroupListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Allows searching for creative groups by name or ID. Wildcards (*) are allowed. For example, "creativegroup*2015" will return creative groups with names like "creativegroup June 2015", "creativegroup April 2015", or simply "creativegroup 2015". Most of the searches also add wild-cards implicitly at the start and the end of the search string. For example, a search string of "creativegroup" will match creative groups with the name "my creativegroup", "creativegroup 2015", or simply "creativegroup". - pub fn search_string(mut self, new_value: &str) -> CreativeGroupListCall<'a, C, NC, A> { + pub fn search_string(mut self, new_value: &str) -> CreativeGroupListCall<'a, C, A> { self._search_string = Some(new_value.to_string()); self } @@ -32692,7 +32688,7 @@ impl<'a, C, NC, A> CreativeGroupListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Value of the nextPageToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> CreativeGroupListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> CreativeGroupListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -32700,7 +32696,7 @@ impl<'a, C, NC, A> CreativeGroupListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> CreativeGroupListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> CreativeGroupListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -32709,7 +32705,7 @@ impl<'a, C, NC, A> CreativeGroupListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Select only creative groups with these IDs. - pub fn add_ids(mut self, new_value: &str) -> CreativeGroupListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> CreativeGroupListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -32717,7 +32713,7 @@ impl<'a, C, NC, A> CreativeGroupListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Select only creative groups that belong to this subgroup. - pub fn group_number(mut self, new_value: i32) -> CreativeGroupListCall<'a, C, NC, A> { + pub fn group_number(mut self, new_value: i32) -> CreativeGroupListCall<'a, C, A> { self._group_number = Some(new_value); self } @@ -32726,7 +32722,7 @@ impl<'a, C, NC, A> CreativeGroupListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Select only creative groups that belong to these advertisers. - pub fn add_advertiser_ids(mut self, new_value: &str) -> CreativeGroupListCall<'a, C, NC, A> { + pub fn add_advertiser_ids(mut self, new_value: &str) -> CreativeGroupListCall<'a, C, A> { self._advertiser_ids.push(new_value.to_string()); self } @@ -32737,7 +32733,7 @@ impl<'a, C, NC, A> CreativeGroupListCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeGroupListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeGroupListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -32758,7 +32754,7 @@ impl<'a, C, NC, A> CreativeGroupListCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeGroupListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeGroupListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -32775,7 +32771,7 @@ impl<'a, C, NC, A> CreativeGroupListCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeGroupListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeGroupListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -32819,10 +32815,10 @@ impl<'a, C, NC, A> CreativeGroupListCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct CreativeGroupPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeGroupPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: CreativeGroup, _profile_id: String, _id: String, @@ -32831,9 +32827,9 @@ pub struct CreativeGroupPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeGroupPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeGroupPatchCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeGroupPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeGroupPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -32973,7 +32969,7 @@ impl<'a, C, NC, A> CreativeGroupPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CreativeGroup) -> CreativeGroupPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CreativeGroup) -> CreativeGroupPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -32983,7 +32979,7 @@ impl<'a, C, NC, A> CreativeGroupPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CreativeGroupPatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CreativeGroupPatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -32993,7 +32989,7 @@ impl<'a, C, NC, A> CreativeGroupPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Creative group ID. - pub fn id(mut self, new_value: &str) -> CreativeGroupPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> CreativeGroupPatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -33004,7 +33000,7 @@ impl<'a, C, NC, A> CreativeGroupPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeGroupPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeGroupPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -33025,7 +33021,7 @@ impl<'a, C, NC, A> CreativeGroupPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeGroupPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeGroupPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -33042,7 +33038,7 @@ impl<'a, C, NC, A> CreativeGroupPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeGroupPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeGroupPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -33086,10 +33082,10 @@ impl<'a, C, NC, A> CreativeGroupPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct SubaccountPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubaccountPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Subaccount, _profile_id: String, _id: String, @@ -33098,9 +33094,9 @@ pub struct SubaccountPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SubaccountPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SubaccountPatchCall<'a, C, A> {} -impl<'a, C, NC, A> SubaccountPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SubaccountPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -33240,7 +33236,7 @@ impl<'a, C, NC, A> SubaccountPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Subaccount) -> SubaccountPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Subaccount) -> SubaccountPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -33250,7 +33246,7 @@ impl<'a, C, NC, A> SubaccountPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> SubaccountPatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> SubaccountPatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -33260,7 +33256,7 @@ impl<'a, C, NC, A> SubaccountPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Subaccount ID. - pub fn id(mut self, new_value: &str) -> SubaccountPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> SubaccountPatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -33271,7 +33267,7 @@ impl<'a, C, NC, A> SubaccountPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubaccountPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubaccountPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -33292,7 +33288,7 @@ impl<'a, C, NC, A> SubaccountPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SubaccountPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SubaccountPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -33309,7 +33305,7 @@ impl<'a, C, NC, A> SubaccountPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SubaccountPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SubaccountPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -33353,10 +33349,10 @@ impl<'a, C, NC, A> SubaccountPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct SubaccountInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubaccountInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Subaccount, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -33364,9 +33360,9 @@ pub struct SubaccountInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SubaccountInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SubaccountInsertCall<'a, C, A> {} -impl<'a, C, NC, A> SubaccountInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SubaccountInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -33505,7 +33501,7 @@ impl<'a, C, NC, A> SubaccountInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Subaccount) -> SubaccountInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Subaccount) -> SubaccountInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -33515,7 +33511,7 @@ impl<'a, C, NC, A> SubaccountInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> SubaccountInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> SubaccountInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -33526,7 +33522,7 @@ impl<'a, C, NC, A> SubaccountInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubaccountInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubaccountInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -33547,7 +33543,7 @@ impl<'a, C, NC, A> SubaccountInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SubaccountInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SubaccountInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -33564,7 +33560,7 @@ impl<'a, C, NC, A> SubaccountInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SubaccountInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SubaccountInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -33608,10 +33604,10 @@ impl<'a, C, NC, A> SubaccountInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct SubaccountListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubaccountListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _sort_order: Option, _sort_field: Option, @@ -33624,9 +33620,9 @@ pub struct SubaccountListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SubaccountListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SubaccountListCall<'a, C, A> {} -impl<'a, C, NC, A> SubaccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SubaccountListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -33780,7 +33776,7 @@ impl<'a, C, NC, A> SubaccountListCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> SubaccountListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> SubaccountListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -33788,7 +33784,7 @@ impl<'a, C, NC, A> SubaccountListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Order of sorted results, default is ASCENDING. - pub fn sort_order(mut self, new_value: &str) -> SubaccountListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> SubaccountListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -33796,7 +33792,7 @@ impl<'a, C, NC, A> SubaccountListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> SubaccountListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> SubaccountListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -33804,7 +33800,7 @@ impl<'a, C, NC, A> SubaccountListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Allows searching for objects by name or ID. Wildcards (*) are allowed. For example, "subaccount*2015" will return objects with names like "subaccount June 2015", "subaccount April 2015", or simply "subaccount 2015". Most of the searches also add wildcards implicitly at the start and the end of the search string. For example, a search string of "subaccount" will match objects with name "my subaccount", "subaccount 2015", or simply "subaccount". - pub fn search_string(mut self, new_value: &str) -> SubaccountListCall<'a, C, NC, A> { + pub fn search_string(mut self, new_value: &str) -> SubaccountListCall<'a, C, A> { self._search_string = Some(new_value.to_string()); self } @@ -33812,7 +33808,7 @@ impl<'a, C, NC, A> SubaccountListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Value of the nextPageToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> SubaccountListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> SubaccountListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -33820,7 +33816,7 @@ impl<'a, C, NC, A> SubaccountListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> SubaccountListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> SubaccountListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -33829,7 +33825,7 @@ impl<'a, C, NC, A> SubaccountListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Select only subaccounts with these IDs. - pub fn add_ids(mut self, new_value: &str) -> SubaccountListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> SubaccountListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -33840,7 +33836,7 @@ impl<'a, C, NC, A> SubaccountListCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubaccountListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubaccountListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -33861,7 +33857,7 @@ impl<'a, C, NC, A> SubaccountListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SubaccountListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SubaccountListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -33878,7 +33874,7 @@ impl<'a, C, NC, A> SubaccountListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SubaccountListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SubaccountListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -33922,10 +33918,10 @@ impl<'a, C, NC, A> SubaccountListCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct SubaccountUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubaccountUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Subaccount, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -33933,9 +33929,9 @@ pub struct SubaccountUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SubaccountUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SubaccountUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> SubaccountUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SubaccountUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -34074,7 +34070,7 @@ impl<'a, C, NC, A> SubaccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Subaccount) -> SubaccountUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Subaccount) -> SubaccountUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -34084,7 +34080,7 @@ impl<'a, C, NC, A> SubaccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> SubaccountUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> SubaccountUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -34095,7 +34091,7 @@ impl<'a, C, NC, A> SubaccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubaccountUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubaccountUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -34116,7 +34112,7 @@ impl<'a, C, NC, A> SubaccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SubaccountUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SubaccountUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -34133,7 +34129,7 @@ impl<'a, C, NC, A> SubaccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SubaccountUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SubaccountUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -34171,10 +34167,10 @@ impl<'a, C, NC, A> SubaccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct SubaccountGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubaccountGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -34182,9 +34178,9 @@ pub struct SubaccountGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SubaccountGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SubaccountGetCall<'a, C, A> {} -impl<'a, C, NC, A> SubaccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SubaccountGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -34317,7 +34313,7 @@ impl<'a, C, NC, A> SubaccountGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> SubaccountGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> SubaccountGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -34327,7 +34323,7 @@ impl<'a, C, NC, A> SubaccountGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Subaccount ID. - pub fn id(mut self, new_value: &str) -> SubaccountGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> SubaccountGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -34338,7 +34334,7 @@ impl<'a, C, NC, A> SubaccountGetCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubaccountGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubaccountGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -34359,7 +34355,7 @@ impl<'a, C, NC, A> SubaccountGetCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SubaccountGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SubaccountGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -34376,7 +34372,7 @@ impl<'a, C, NC, A> SubaccountGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SubaccountGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SubaccountGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -34414,19 +34410,19 @@ impl<'a, C, NC, A> SubaccountGetCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct MobileCarrierListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MobileCarrierListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MobileCarrierListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MobileCarrierListCall<'a, C, A> {} -impl<'a, C, NC, A> MobileCarrierListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MobileCarrierListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -34558,7 +34554,7 @@ impl<'a, C, NC, A> MobileCarrierListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> MobileCarrierListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> MobileCarrierListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -34569,7 +34565,7 @@ impl<'a, C, NC, A> MobileCarrierListCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MobileCarrierListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MobileCarrierListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -34590,7 +34586,7 @@ impl<'a, C, NC, A> MobileCarrierListCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MobileCarrierListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MobileCarrierListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -34607,7 +34603,7 @@ impl<'a, C, NC, A> MobileCarrierListCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MobileCarrierListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MobileCarrierListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -34651,10 +34647,10 @@ impl<'a, C, NC, A> MobileCarrierListCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct FloodlightConfigurationUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FloodlightConfigurationUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: FloodlightConfiguration, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -34662,9 +34658,9 @@ pub struct FloodlightConfigurationUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FloodlightConfigurationUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FloodlightConfigurationUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> FloodlightConfigurationUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FloodlightConfigurationUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -34803,7 +34799,7 @@ impl<'a, C, NC, A> FloodlightConfigurationUpdateCall<'a, C, NC, A> where NC: hyp /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &FloodlightConfiguration) -> FloodlightConfigurationUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &FloodlightConfiguration) -> FloodlightConfigurationUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -34813,7 +34809,7 @@ impl<'a, C, NC, A> FloodlightConfigurationUpdateCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> FloodlightConfigurationUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> FloodlightConfigurationUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -34824,7 +34820,7 @@ impl<'a, C, NC, A> FloodlightConfigurationUpdateCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightConfigurationUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightConfigurationUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -34845,7 +34841,7 @@ impl<'a, C, NC, A> FloodlightConfigurationUpdateCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FloodlightConfigurationUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FloodlightConfigurationUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -34862,7 +34858,7 @@ impl<'a, C, NC, A> FloodlightConfigurationUpdateCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FloodlightConfigurationUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FloodlightConfigurationUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -34906,10 +34902,10 @@ impl<'a, C, NC, A> FloodlightConfigurationUpdateCall<'a, C, NC, A> where NC: hyp /// .doit(); /// # } /// ``` -pub struct FloodlightConfigurationPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FloodlightConfigurationPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: FloodlightConfiguration, _profile_id: String, _id: String, @@ -34918,9 +34914,9 @@ pub struct FloodlightConfigurationPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FloodlightConfigurationPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FloodlightConfigurationPatchCall<'a, C, A> {} -impl<'a, C, NC, A> FloodlightConfigurationPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FloodlightConfigurationPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -35060,7 +35056,7 @@ impl<'a, C, NC, A> FloodlightConfigurationPatchCall<'a, C, NC, A> where NC: hype /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &FloodlightConfiguration) -> FloodlightConfigurationPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &FloodlightConfiguration) -> FloodlightConfigurationPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -35070,7 +35066,7 @@ impl<'a, C, NC, A> FloodlightConfigurationPatchCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> FloodlightConfigurationPatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> FloodlightConfigurationPatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -35080,7 +35076,7 @@ impl<'a, C, NC, A> FloodlightConfigurationPatchCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// Floodlight configuration ID. - pub fn id(mut self, new_value: &str) -> FloodlightConfigurationPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> FloodlightConfigurationPatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -35091,7 +35087,7 @@ impl<'a, C, NC, A> FloodlightConfigurationPatchCall<'a, C, NC, A> where NC: hype /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightConfigurationPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightConfigurationPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -35112,7 +35108,7 @@ impl<'a, C, NC, A> FloodlightConfigurationPatchCall<'a, C, NC, A> where NC: hype /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FloodlightConfigurationPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FloodlightConfigurationPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -35129,7 +35125,7 @@ impl<'a, C, NC, A> FloodlightConfigurationPatchCall<'a, C, NC, A> where NC: hype /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FloodlightConfigurationPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FloodlightConfigurationPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -35167,10 +35163,10 @@ impl<'a, C, NC, A> FloodlightConfigurationPatchCall<'a, C, NC, A> where NC: hype /// .doit(); /// # } /// ``` -pub struct FloodlightConfigurationGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FloodlightConfigurationGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -35178,9 +35174,9 @@ pub struct FloodlightConfigurationGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FloodlightConfigurationGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FloodlightConfigurationGetCall<'a, C, A> {} -impl<'a, C, NC, A> FloodlightConfigurationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FloodlightConfigurationGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -35313,7 +35309,7 @@ impl<'a, C, NC, A> FloodlightConfigurationGetCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> FloodlightConfigurationGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> FloodlightConfigurationGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -35323,7 +35319,7 @@ impl<'a, C, NC, A> FloodlightConfigurationGetCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Floodlight configuration ID. - pub fn id(mut self, new_value: &str) -> FloodlightConfigurationGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> FloodlightConfigurationGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -35334,7 +35330,7 @@ impl<'a, C, NC, A> FloodlightConfigurationGetCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightConfigurationGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightConfigurationGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -35355,7 +35351,7 @@ impl<'a, C, NC, A> FloodlightConfigurationGetCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FloodlightConfigurationGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FloodlightConfigurationGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -35372,7 +35368,7 @@ impl<'a, C, NC, A> FloodlightConfigurationGetCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FloodlightConfigurationGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FloodlightConfigurationGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -35411,10 +35407,10 @@ impl<'a, C, NC, A> FloodlightConfigurationGetCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct FloodlightConfigurationListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FloodlightConfigurationListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _ids: Vec, _delegate: Option<&'a mut Delegate>, @@ -35422,9 +35418,9 @@ pub struct FloodlightConfigurationListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FloodlightConfigurationListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FloodlightConfigurationListCall<'a, C, A> {} -impl<'a, C, NC, A> FloodlightConfigurationListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FloodlightConfigurationListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -35563,7 +35559,7 @@ impl<'a, C, NC, A> FloodlightConfigurationListCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> FloodlightConfigurationListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> FloodlightConfigurationListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -35572,7 +35568,7 @@ impl<'a, C, NC, A> FloodlightConfigurationListCall<'a, C, NC, A> where NC: hyper /// /// /// Set of IDs of floodlight configurations to retrieve. Required field; otherwise an empty list will be returned. - pub fn add_ids(mut self, new_value: &str) -> FloodlightConfigurationListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> FloodlightConfigurationListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -35583,7 +35579,7 @@ impl<'a, C, NC, A> FloodlightConfigurationListCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightConfigurationListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FloodlightConfigurationListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -35604,7 +35600,7 @@ impl<'a, C, NC, A> FloodlightConfigurationListCall<'a, C, NC, A> where NC: hyper /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FloodlightConfigurationListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FloodlightConfigurationListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -35621,7 +35617,7 @@ impl<'a, C, NC, A> FloodlightConfigurationListCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FloodlightConfigurationListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FloodlightConfigurationListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -35659,19 +35655,19 @@ impl<'a, C, NC, A> FloodlightConfigurationListCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct OperatingSystemListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct OperatingSystemListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for OperatingSystemListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for OperatingSystemListCall<'a, C, A> {} -impl<'a, C, NC, A> OperatingSystemListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> OperatingSystemListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -35803,7 +35799,7 @@ impl<'a, C, NC, A> OperatingSystemListCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> OperatingSystemListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> OperatingSystemListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -35814,7 +35810,7 @@ impl<'a, C, NC, A> OperatingSystemListCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> OperatingSystemListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> OperatingSystemListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -35835,7 +35831,7 @@ impl<'a, C, NC, A> OperatingSystemListCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> OperatingSystemListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> OperatingSystemListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -35852,7 +35848,7 @@ impl<'a, C, NC, A> OperatingSystemListCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> OperatingSystemListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> OperatingSystemListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -35895,10 +35891,10 @@ impl<'a, C, NC, A> OperatingSystemListCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct FileListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FileListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _sort_order: Option, _sort_field: Option, @@ -35910,9 +35906,9 @@ pub struct FileListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FileListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FileListCall<'a, C, A> {} -impl<'a, C, NC, A> FileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FileListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -36059,7 +36055,7 @@ impl<'a, C, NC, A> FileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The DFA profile ID. - pub fn profile_id(mut self, new_value: &str) -> FileListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> FileListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -36067,7 +36063,7 @@ impl<'a, C, NC, A> FileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Order of sorted results, default is 'DESCENDING'. - pub fn sort_order(mut self, new_value: &str) -> FileListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> FileListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -36075,7 +36071,7 @@ impl<'a, C, NC, A> FileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> FileListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> FileListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -36083,7 +36079,7 @@ impl<'a, C, NC, A> FileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The scope that defines which results are returned, default is 'MINE'. - pub fn scope(mut self, new_value: &str) -> FileListCall<'a, C, NC, A> { + pub fn scope(mut self, new_value: &str) -> FileListCall<'a, C, A> { self._scope = Some(new_value.to_string()); self } @@ -36091,7 +36087,7 @@ impl<'a, C, NC, A> FileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The value of the nextToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> FileListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> FileListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -36099,7 +36095,7 @@ impl<'a, C, NC, A> FileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> FileListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> FileListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -36110,7 +36106,7 @@ impl<'a, C, NC, A> FileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -36131,7 +36127,7 @@ impl<'a, C, NC, A> FileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FileListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FileListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -36148,7 +36144,7 @@ impl<'a, C, NC, A> FileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FileListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FileListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -36191,10 +36187,10 @@ impl<'a, C, NC, A> FileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct FileGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FileGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _report_id: String, _file_id: String, _delegate: Option<&'a mut Delegate>, @@ -36202,9 +36198,9 @@ pub struct FileGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FileGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FileGetCall<'a, C, A> {} -impl<'a, C, NC, A> FileGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FileGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -36353,7 +36349,7 @@ impl<'a, C, NC, A> FileGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// The ID of the report. - pub fn report_id(mut self, new_value: &str) -> FileGetCall<'a, C, NC, A> { + pub fn report_id(mut self, new_value: &str) -> FileGetCall<'a, C, A> { self._report_id = new_value.to_string(); self } @@ -36363,7 +36359,7 @@ impl<'a, C, NC, A> FileGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// The ID of the report file. - pub fn file_id(mut self, new_value: &str) -> FileGetCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> FileGetCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -36374,7 +36370,7 @@ impl<'a, C, NC, A> FileGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -36395,7 +36391,7 @@ impl<'a, C, NC, A> FileGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FileGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FileGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -36412,7 +36408,7 @@ impl<'a, C, NC, A> FileGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FileGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FileGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -36465,10 +36461,10 @@ impl<'a, C, NC, A> FileGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct PlacementGroupListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlacementGroupListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _sort_order: Option, _sort_field: Option, @@ -36490,9 +36486,9 @@ pub struct PlacementGroupListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlacementGroupListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlacementGroupListCall<'a, C, A> {} -impl<'a, C, NC, A> PlacementGroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlacementGroupListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -36701,7 +36697,7 @@ impl<'a, C, NC, A> PlacementGroupListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -36709,7 +36705,7 @@ impl<'a, C, NC, A> PlacementGroupListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Order of sorted results, default is ASCENDING. - pub fn sort_order(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -36717,7 +36713,7 @@ impl<'a, C, NC, A> PlacementGroupListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -36726,7 +36722,7 @@ impl<'a, C, NC, A> PlacementGroupListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Select only placement groups that are associated with these sites. - pub fn add_site_ids(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, NC, A> { + pub fn add_site_ids(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, A> { self._site_ids.push(new_value.to_string()); self } @@ -36734,7 +36730,7 @@ impl<'a, C, NC, A> PlacementGroupListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Allows searching for placement groups by name or ID. Wildcards (*) are allowed. For example, "placement*2015" will return placement groups with names like "placement group June 2015", "placement group May 2015", or simply "placements 2015". Most of the searches also add wildcards implicitly at the start and the end of the search string. For example, a search string of "placementgroup" will match placement groups with name "my placementgroup", "placementgroup 2015", or simply "placementgroup". - pub fn search_string(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, NC, A> { + pub fn search_string(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, A> { self._search_string = Some(new_value.to_string()); self } @@ -36743,7 +36739,7 @@ impl<'a, C, NC, A> PlacementGroupListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Select only placement groups with these pricing types. - pub fn add_pricing_types(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, NC, A> { + pub fn add_pricing_types(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, A> { self._pricing_types.push(new_value.to_string()); self } @@ -36752,7 +36748,7 @@ impl<'a, C, NC, A> PlacementGroupListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Select only placement groups that are associated with these placement strategies. - pub fn add_placement_strategy_ids(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, NC, A> { + pub fn add_placement_strategy_ids(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, A> { self._placement_strategy_ids.push(new_value.to_string()); self } @@ -36760,7 +36756,7 @@ impl<'a, C, NC, A> PlacementGroupListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Select only placement groups belonging with this group type. A package is a simple group of placements that acts as a single pricing point for a group of tags. A roadblock is a group of placements that not only acts as a single pricing point but also assumes that all the tags in it will be served at the same time. A roadblock requires one of its assigned placements to be marked as primary for reporting. - pub fn placement_group_type(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, NC, A> { + pub fn placement_group_type(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, A> { self._placement_group_type = Some(new_value.to_string()); self } @@ -36768,7 +36764,7 @@ impl<'a, C, NC, A> PlacementGroupListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Value of the nextPageToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -36776,7 +36772,7 @@ impl<'a, C, NC, A> PlacementGroupListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> PlacementGroupListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> PlacementGroupListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -36785,7 +36781,7 @@ impl<'a, C, NC, A> PlacementGroupListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Select only placement groups with these IDs. - pub fn add_ids(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -36794,7 +36790,7 @@ impl<'a, C, NC, A> PlacementGroupListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Select only placement groups that are associated with these directory sites. - pub fn add_directory_site_ids(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, NC, A> { + pub fn add_directory_site_ids(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, A> { self._directory_site_ids.push(new_value.to_string()); self } @@ -36803,7 +36799,7 @@ impl<'a, C, NC, A> PlacementGroupListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Select only placement groups that are associated with these content categories. - pub fn add_content_category_ids(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, NC, A> { + pub fn add_content_category_ids(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, A> { self._content_category_ids.push(new_value.to_string()); self } @@ -36812,7 +36808,7 @@ impl<'a, C, NC, A> PlacementGroupListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Select only placement groups that belong to these campaigns. - pub fn add_campaign_ids(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, NC, A> { + pub fn add_campaign_ids(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, A> { self._campaign_ids.push(new_value.to_string()); self } @@ -36820,7 +36816,7 @@ impl<'a, C, NC, A> PlacementGroupListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Select only archived placements. Don't set this field to select both archived and non-archived placements. - pub fn archived(mut self, new_value: bool) -> PlacementGroupListCall<'a, C, NC, A> { + pub fn archived(mut self, new_value: bool) -> PlacementGroupListCall<'a, C, A> { self._archived = Some(new_value); self } @@ -36829,7 +36825,7 @@ impl<'a, C, NC, A> PlacementGroupListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Select only placement groups that belong to these advertisers. - pub fn add_advertiser_ids(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, NC, A> { + pub fn add_advertiser_ids(mut self, new_value: &str) -> PlacementGroupListCall<'a, C, A> { self._advertiser_ids.push(new_value.to_string()); self } @@ -36840,7 +36836,7 @@ impl<'a, C, NC, A> PlacementGroupListCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementGroupListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementGroupListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -36861,7 +36857,7 @@ impl<'a, C, NC, A> PlacementGroupListCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlacementGroupListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlacementGroupListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -36878,7 +36874,7 @@ impl<'a, C, NC, A> PlacementGroupListCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlacementGroupListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlacementGroupListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -36922,10 +36918,10 @@ impl<'a, C, NC, A> PlacementGroupListCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct PlacementGroupUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlacementGroupUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: PlacementGroup, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -36933,9 +36929,9 @@ pub struct PlacementGroupUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlacementGroupUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlacementGroupUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> PlacementGroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlacementGroupUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -37074,7 +37070,7 @@ impl<'a, C, NC, A> PlacementGroupUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PlacementGroup) -> PlacementGroupUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PlacementGroup) -> PlacementGroupUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -37084,7 +37080,7 @@ impl<'a, C, NC, A> PlacementGroupUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> PlacementGroupUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> PlacementGroupUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -37095,7 +37091,7 @@ impl<'a, C, NC, A> PlacementGroupUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementGroupUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementGroupUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -37116,7 +37112,7 @@ impl<'a, C, NC, A> PlacementGroupUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlacementGroupUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlacementGroupUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -37133,7 +37129,7 @@ impl<'a, C, NC, A> PlacementGroupUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlacementGroupUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlacementGroupUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -37177,10 +37173,10 @@ impl<'a, C, NC, A> PlacementGroupUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct PlacementGroupInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlacementGroupInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: PlacementGroup, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -37188,9 +37184,9 @@ pub struct PlacementGroupInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlacementGroupInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlacementGroupInsertCall<'a, C, A> {} -impl<'a, C, NC, A> PlacementGroupInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlacementGroupInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -37329,7 +37325,7 @@ impl<'a, C, NC, A> PlacementGroupInsertCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PlacementGroup) -> PlacementGroupInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PlacementGroup) -> PlacementGroupInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -37339,7 +37335,7 @@ impl<'a, C, NC, A> PlacementGroupInsertCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> PlacementGroupInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> PlacementGroupInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -37350,7 +37346,7 @@ impl<'a, C, NC, A> PlacementGroupInsertCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementGroupInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementGroupInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -37371,7 +37367,7 @@ impl<'a, C, NC, A> PlacementGroupInsertCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlacementGroupInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlacementGroupInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -37388,7 +37384,7 @@ impl<'a, C, NC, A> PlacementGroupInsertCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlacementGroupInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlacementGroupInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -37426,10 +37422,10 @@ impl<'a, C, NC, A> PlacementGroupInsertCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct PlacementGroupGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlacementGroupGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -37437,9 +37433,9 @@ pub struct PlacementGroupGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlacementGroupGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlacementGroupGetCall<'a, C, A> {} -impl<'a, C, NC, A> PlacementGroupGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlacementGroupGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -37572,7 +37568,7 @@ impl<'a, C, NC, A> PlacementGroupGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> PlacementGroupGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> PlacementGroupGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -37582,7 +37578,7 @@ impl<'a, C, NC, A> PlacementGroupGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Placement group ID. - pub fn id(mut self, new_value: &str) -> PlacementGroupGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> PlacementGroupGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -37593,7 +37589,7 @@ impl<'a, C, NC, A> PlacementGroupGetCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementGroupGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementGroupGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -37614,7 +37610,7 @@ impl<'a, C, NC, A> PlacementGroupGetCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlacementGroupGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlacementGroupGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -37631,7 +37627,7 @@ impl<'a, C, NC, A> PlacementGroupGetCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlacementGroupGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlacementGroupGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -37675,10 +37671,10 @@ impl<'a, C, NC, A> PlacementGroupGetCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct PlacementGroupPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlacementGroupPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: PlacementGroup, _profile_id: String, _id: String, @@ -37687,9 +37683,9 @@ pub struct PlacementGroupPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlacementGroupPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlacementGroupPatchCall<'a, C, A> {} -impl<'a, C, NC, A> PlacementGroupPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlacementGroupPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -37829,7 +37825,7 @@ impl<'a, C, NC, A> PlacementGroupPatchCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PlacementGroup) -> PlacementGroupPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PlacementGroup) -> PlacementGroupPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -37839,7 +37835,7 @@ impl<'a, C, NC, A> PlacementGroupPatchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> PlacementGroupPatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> PlacementGroupPatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -37849,7 +37845,7 @@ impl<'a, C, NC, A> PlacementGroupPatchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Placement group ID. - pub fn id(mut self, new_value: &str) -> PlacementGroupPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> PlacementGroupPatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -37860,7 +37856,7 @@ impl<'a, C, NC, A> PlacementGroupPatchCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementGroupPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementGroupPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -37881,7 +37877,7 @@ impl<'a, C, NC, A> PlacementGroupPatchCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlacementGroupPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlacementGroupPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -37898,7 +37894,7 @@ impl<'a, C, NC, A> PlacementGroupPatchCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlacementGroupPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlacementGroupPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -37943,10 +37939,10 @@ impl<'a, C, NC, A> PlacementGroupPatchCall<'a, C, NC, A> where NC: hyper::net::N /// .upload_resumable(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct CreativeAssetInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeAssetInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: CreativeAssetMetadata, _profile_id: String, _advertiser_id: String, @@ -37955,9 +37951,9 @@ pub struct CreativeAssetInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeAssetInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeAssetInsertCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeAssetInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeAssetInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -38211,7 +38207,7 @@ impl<'a, C, NC, A> CreativeAssetInsertCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CreativeAssetMetadata) -> CreativeAssetInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CreativeAssetMetadata) -> CreativeAssetInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -38221,7 +38217,7 @@ impl<'a, C, NC, A> CreativeAssetInsertCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CreativeAssetInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CreativeAssetInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -38231,7 +38227,7 @@ impl<'a, C, NC, A> CreativeAssetInsertCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Advertiser ID of this creative. This is a required field. - pub fn advertiser_id(mut self, new_value: &str) -> CreativeAssetInsertCall<'a, C, NC, A> { + pub fn advertiser_id(mut self, new_value: &str) -> CreativeAssetInsertCall<'a, C, A> { self._advertiser_id = new_value.to_string(); self } @@ -38242,7 +38238,7 @@ impl<'a, C, NC, A> CreativeAssetInsertCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeAssetInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeAssetInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -38263,7 +38259,7 @@ impl<'a, C, NC, A> CreativeAssetInsertCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeAssetInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeAssetInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -38280,7 +38276,7 @@ impl<'a, C, NC, A> CreativeAssetInsertCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeAssetInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeAssetInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -38318,10 +38314,10 @@ impl<'a, C, NC, A> CreativeAssetInsertCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct UserRolePermissionGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserRolePermissionGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -38329,9 +38325,9 @@ pub struct UserRolePermissionGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserRolePermissionGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserRolePermissionGetCall<'a, C, A> {} -impl<'a, C, NC, A> UserRolePermissionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserRolePermissionGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -38464,7 +38460,7 @@ impl<'a, C, NC, A> UserRolePermissionGetCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> UserRolePermissionGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> UserRolePermissionGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -38474,7 +38470,7 @@ impl<'a, C, NC, A> UserRolePermissionGetCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// User role permission ID. - pub fn id(mut self, new_value: &str) -> UserRolePermissionGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> UserRolePermissionGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -38485,7 +38481,7 @@ impl<'a, C, NC, A> UserRolePermissionGetCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserRolePermissionGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserRolePermissionGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -38506,7 +38502,7 @@ impl<'a, C, NC, A> UserRolePermissionGetCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserRolePermissionGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserRolePermissionGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -38523,7 +38519,7 @@ impl<'a, C, NC, A> UserRolePermissionGetCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserRolePermissionGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserRolePermissionGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -38562,10 +38558,10 @@ impl<'a, C, NC, A> UserRolePermissionGetCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct UserRolePermissionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserRolePermissionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _ids: Vec, _delegate: Option<&'a mut Delegate>, @@ -38573,9 +38569,9 @@ pub struct UserRolePermissionListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserRolePermissionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserRolePermissionListCall<'a, C, A> {} -impl<'a, C, NC, A> UserRolePermissionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserRolePermissionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -38714,7 +38710,7 @@ impl<'a, C, NC, A> UserRolePermissionListCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> UserRolePermissionListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> UserRolePermissionListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -38723,7 +38719,7 @@ impl<'a, C, NC, A> UserRolePermissionListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Select only user role permissions with these IDs. - pub fn add_ids(mut self, new_value: &str) -> UserRolePermissionListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> UserRolePermissionListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -38734,7 +38730,7 @@ impl<'a, C, NC, A> UserRolePermissionListCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserRolePermissionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserRolePermissionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -38755,7 +38751,7 @@ impl<'a, C, NC, A> UserRolePermissionListCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserRolePermissionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserRolePermissionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -38772,7 +38768,7 @@ impl<'a, C, NC, A> UserRolePermissionListCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserRolePermissionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserRolePermissionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -38810,19 +38806,19 @@ impl<'a, C, NC, A> UserRolePermissionListCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct AccountPermissionGroupListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountPermissionGroupListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountPermissionGroupListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountPermissionGroupListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountPermissionGroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountPermissionGroupListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -38954,7 +38950,7 @@ impl<'a, C, NC, A> AccountPermissionGroupListCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AccountPermissionGroupListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AccountPermissionGroupListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -38965,7 +38961,7 @@ impl<'a, C, NC, A> AccountPermissionGroupListCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPermissionGroupListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPermissionGroupListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -38986,7 +38982,7 @@ impl<'a, C, NC, A> AccountPermissionGroupListCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountPermissionGroupListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountPermissionGroupListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -39003,7 +38999,7 @@ impl<'a, C, NC, A> AccountPermissionGroupListCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountPermissionGroupListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountPermissionGroupListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -39041,10 +39037,10 @@ impl<'a, C, NC, A> AccountPermissionGroupListCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct AccountPermissionGroupGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountPermissionGroupGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -39052,9 +39048,9 @@ pub struct AccountPermissionGroupGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountPermissionGroupGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountPermissionGroupGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountPermissionGroupGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountPermissionGroupGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -39187,7 +39183,7 @@ impl<'a, C, NC, A> AccountPermissionGroupGetCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AccountPermissionGroupGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AccountPermissionGroupGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -39197,7 +39193,7 @@ impl<'a, C, NC, A> AccountPermissionGroupGetCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Account permission group ID. - pub fn id(mut self, new_value: &str) -> AccountPermissionGroupGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> AccountPermissionGroupGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -39208,7 +39204,7 @@ impl<'a, C, NC, A> AccountPermissionGroupGetCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPermissionGroupGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPermissionGroupGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -39229,7 +39225,7 @@ impl<'a, C, NC, A> AccountPermissionGroupGetCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountPermissionGroupGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountPermissionGroupGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -39246,7 +39242,7 @@ impl<'a, C, NC, A> AccountPermissionGroupGetCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountPermissionGroupGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountPermissionGroupGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -39290,10 +39286,10 @@ impl<'a, C, NC, A> AccountPermissionGroupGetCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct ContentCategoryListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ContentCategoryListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _sort_order: Option, _sort_field: Option, @@ -39306,9 +39302,9 @@ pub struct ContentCategoryListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ContentCategoryListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ContentCategoryListCall<'a, C, A> {} -impl<'a, C, NC, A> ContentCategoryListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ContentCategoryListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -39462,7 +39458,7 @@ impl<'a, C, NC, A> ContentCategoryListCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> ContentCategoryListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ContentCategoryListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -39470,7 +39466,7 @@ impl<'a, C, NC, A> ContentCategoryListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Order of sorted results, default is ASCENDING. - pub fn sort_order(mut self, new_value: &str) -> ContentCategoryListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> ContentCategoryListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -39478,7 +39474,7 @@ impl<'a, C, NC, A> ContentCategoryListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> ContentCategoryListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> ContentCategoryListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -39486,7 +39482,7 @@ impl<'a, C, NC, A> ContentCategoryListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Allows searching for objects by name or ID. Wildcards (*) are allowed. For example, "contentcategory*2015" will return objects with names like "contentcategory June 2015", "contentcategory April 2015", or simply "contentcategory 2015". Most of the searches also add wildcards implicitly at the start and the end of the search string. For example, a search string of "contentcategory" will match objects with name "my contentcategory", "contentcategory 2015", or simply "contentcategory". - pub fn search_string(mut self, new_value: &str) -> ContentCategoryListCall<'a, C, NC, A> { + pub fn search_string(mut self, new_value: &str) -> ContentCategoryListCall<'a, C, A> { self._search_string = Some(new_value.to_string()); self } @@ -39494,7 +39490,7 @@ impl<'a, C, NC, A> ContentCategoryListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Value of the nextPageToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> ContentCategoryListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ContentCategoryListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -39502,7 +39498,7 @@ impl<'a, C, NC, A> ContentCategoryListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> ContentCategoryListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ContentCategoryListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -39511,7 +39507,7 @@ impl<'a, C, NC, A> ContentCategoryListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// Select only content categories with these IDs. - pub fn add_ids(mut self, new_value: &str) -> ContentCategoryListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> ContentCategoryListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -39522,7 +39518,7 @@ impl<'a, C, NC, A> ContentCategoryListCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContentCategoryListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContentCategoryListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -39543,7 +39539,7 @@ impl<'a, C, NC, A> ContentCategoryListCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ContentCategoryListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ContentCategoryListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -39560,7 +39556,7 @@ impl<'a, C, NC, A> ContentCategoryListCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ContentCategoryListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ContentCategoryListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -39604,10 +39600,10 @@ impl<'a, C, NC, A> ContentCategoryListCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct ContentCategoryUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ContentCategoryUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: ContentCategory, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -39615,9 +39611,9 @@ pub struct ContentCategoryUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ContentCategoryUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ContentCategoryUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ContentCategoryUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ContentCategoryUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -39756,7 +39752,7 @@ impl<'a, C, NC, A> ContentCategoryUpdateCall<'a, C, NC, A> where NC: hyper::net: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ContentCategory) -> ContentCategoryUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ContentCategory) -> ContentCategoryUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -39766,7 +39762,7 @@ impl<'a, C, NC, A> ContentCategoryUpdateCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> ContentCategoryUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ContentCategoryUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -39777,7 +39773,7 @@ impl<'a, C, NC, A> ContentCategoryUpdateCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContentCategoryUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContentCategoryUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -39798,7 +39794,7 @@ impl<'a, C, NC, A> ContentCategoryUpdateCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ContentCategoryUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ContentCategoryUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -39815,7 +39811,7 @@ impl<'a, C, NC, A> ContentCategoryUpdateCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ContentCategoryUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ContentCategoryUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -39859,10 +39855,10 @@ impl<'a, C, NC, A> ContentCategoryUpdateCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct ContentCategoryInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ContentCategoryInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: ContentCategory, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -39870,9 +39866,9 @@ pub struct ContentCategoryInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ContentCategoryInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ContentCategoryInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ContentCategoryInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ContentCategoryInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -40011,7 +40007,7 @@ impl<'a, C, NC, A> ContentCategoryInsertCall<'a, C, NC, A> where NC: hyper::net: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ContentCategory) -> ContentCategoryInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ContentCategory) -> ContentCategoryInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -40021,7 +40017,7 @@ impl<'a, C, NC, A> ContentCategoryInsertCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> ContentCategoryInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ContentCategoryInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -40032,7 +40028,7 @@ impl<'a, C, NC, A> ContentCategoryInsertCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContentCategoryInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContentCategoryInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -40053,7 +40049,7 @@ impl<'a, C, NC, A> ContentCategoryInsertCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ContentCategoryInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ContentCategoryInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -40070,7 +40066,7 @@ impl<'a, C, NC, A> ContentCategoryInsertCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ContentCategoryInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ContentCategoryInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -40108,10 +40104,10 @@ impl<'a, C, NC, A> ContentCategoryInsertCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct ContentCategoryDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ContentCategoryDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -40119,9 +40115,9 @@ pub struct ContentCategoryDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ContentCategoryDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ContentCategoryDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ContentCategoryDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ContentCategoryDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -40243,7 +40239,7 @@ impl<'a, C, NC, A> ContentCategoryDeleteCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> ContentCategoryDeleteCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ContentCategoryDeleteCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -40253,7 +40249,7 @@ impl<'a, C, NC, A> ContentCategoryDeleteCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Content category ID. - pub fn id(mut self, new_value: &str) -> ContentCategoryDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> ContentCategoryDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -40264,7 +40260,7 @@ impl<'a, C, NC, A> ContentCategoryDeleteCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContentCategoryDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContentCategoryDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -40285,7 +40281,7 @@ impl<'a, C, NC, A> ContentCategoryDeleteCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ContentCategoryDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ContentCategoryDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -40302,7 +40298,7 @@ impl<'a, C, NC, A> ContentCategoryDeleteCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ContentCategoryDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ContentCategoryDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -40340,10 +40336,10 @@ impl<'a, C, NC, A> ContentCategoryDeleteCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct ContentCategoryGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ContentCategoryGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -40351,9 +40347,9 @@ pub struct ContentCategoryGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ContentCategoryGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ContentCategoryGetCall<'a, C, A> {} -impl<'a, C, NC, A> ContentCategoryGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ContentCategoryGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -40486,7 +40482,7 @@ impl<'a, C, NC, A> ContentCategoryGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> ContentCategoryGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ContentCategoryGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -40496,7 +40492,7 @@ impl<'a, C, NC, A> ContentCategoryGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Content category ID. - pub fn id(mut self, new_value: &str) -> ContentCategoryGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> ContentCategoryGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -40507,7 +40503,7 @@ impl<'a, C, NC, A> ContentCategoryGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContentCategoryGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContentCategoryGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -40528,7 +40524,7 @@ impl<'a, C, NC, A> ContentCategoryGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ContentCategoryGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ContentCategoryGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -40545,7 +40541,7 @@ impl<'a, C, NC, A> ContentCategoryGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ContentCategoryGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ContentCategoryGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -40589,10 +40585,10 @@ impl<'a, C, NC, A> ContentCategoryGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct ContentCategoryPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ContentCategoryPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: ContentCategory, _profile_id: String, _id: String, @@ -40601,9 +40597,9 @@ pub struct ContentCategoryPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ContentCategoryPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ContentCategoryPatchCall<'a, C, A> {} -impl<'a, C, NC, A> ContentCategoryPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ContentCategoryPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -40743,7 +40739,7 @@ impl<'a, C, NC, A> ContentCategoryPatchCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ContentCategory) -> ContentCategoryPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ContentCategory) -> ContentCategoryPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -40753,7 +40749,7 @@ impl<'a, C, NC, A> ContentCategoryPatchCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> ContentCategoryPatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ContentCategoryPatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -40763,7 +40759,7 @@ impl<'a, C, NC, A> ContentCategoryPatchCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Content category ID. - pub fn id(mut self, new_value: &str) -> ContentCategoryPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> ContentCategoryPatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -40774,7 +40770,7 @@ impl<'a, C, NC, A> ContentCategoryPatchCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContentCategoryPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContentCategoryPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -40795,7 +40791,7 @@ impl<'a, C, NC, A> ContentCategoryPatchCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ContentCategoryPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ContentCategoryPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -40812,7 +40808,7 @@ impl<'a, C, NC, A> ContentCategoryPatchCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ContentCategoryPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ContentCategoryPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -40856,10 +40852,10 @@ impl<'a, C, NC, A> ContentCategoryPatchCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct CreativeInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Creative, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -40867,9 +40863,9 @@ pub struct CreativeInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeInsertCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -41008,7 +41004,7 @@ impl<'a, C, NC, A> CreativeInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Creative) -> CreativeInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Creative) -> CreativeInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -41018,7 +41014,7 @@ impl<'a, C, NC, A> CreativeInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CreativeInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CreativeInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -41029,7 +41025,7 @@ impl<'a, C, NC, A> CreativeInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -41050,7 +41046,7 @@ impl<'a, C, NC, A> CreativeInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -41067,7 +41063,7 @@ impl<'a, C, NC, A> CreativeInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -41111,10 +41107,10 @@ impl<'a, C, NC, A> CreativeInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct CreativeUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Creative, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -41122,9 +41118,9 @@ pub struct CreativeUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -41263,7 +41259,7 @@ impl<'a, C, NC, A> CreativeUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Creative) -> CreativeUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Creative) -> CreativeUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -41273,7 +41269,7 @@ impl<'a, C, NC, A> CreativeUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CreativeUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CreativeUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -41284,7 +41280,7 @@ impl<'a, C, NC, A> CreativeUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -41305,7 +41301,7 @@ impl<'a, C, NC, A> CreativeUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -41322,7 +41318,7 @@ impl<'a, C, NC, A> CreativeUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -41360,10 +41356,10 @@ impl<'a, C, NC, A> CreativeUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct CreativeGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -41371,9 +41367,9 @@ pub struct CreativeGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeGetCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -41506,7 +41502,7 @@ impl<'a, C, NC, A> CreativeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CreativeGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CreativeGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -41516,7 +41512,7 @@ impl<'a, C, NC, A> CreativeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Creative ID. - pub fn id(mut self, new_value: &str) -> CreativeGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> CreativeGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -41527,7 +41523,7 @@ impl<'a, C, NC, A> CreativeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -41548,7 +41544,7 @@ impl<'a, C, NC, A> CreativeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -41565,7 +41561,7 @@ impl<'a, C, NC, A> CreativeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -41619,10 +41615,10 @@ impl<'a, C, NC, A> CreativeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct CreativeListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _types: Vec, _studio_creative_id: Option, @@ -41645,9 +41641,9 @@ pub struct CreativeListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeListCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -41851,7 +41847,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CreativeListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CreativeListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -41860,7 +41856,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only creatives with these creative types. - pub fn add_types(mut self, new_value: &str) -> CreativeListCall<'a, C, NC, A> { + pub fn add_types(mut self, new_value: &str) -> CreativeListCall<'a, C, A> { self._types.push(new_value.to_string()); self } @@ -41868,7 +41864,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only creatives corresponding to this Studio creative ID. - pub fn studio_creative_id(mut self, new_value: &str) -> CreativeListCall<'a, C, NC, A> { + pub fn studio_creative_id(mut self, new_value: &str) -> CreativeListCall<'a, C, A> { self._studio_creative_id = Some(new_value.to_string()); self } @@ -41876,7 +41872,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Order of sorted results, default is ASCENDING. - pub fn sort_order(mut self, new_value: &str) -> CreativeListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> CreativeListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -41884,7 +41880,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> CreativeListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> CreativeListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -41893,7 +41889,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only creatives with these size IDs. - pub fn add_size_ids(mut self, new_value: &str) -> CreativeListCall<'a, C, NC, A> { + pub fn add_size_ids(mut self, new_value: &str) -> CreativeListCall<'a, C, A> { self._size_ids.push(new_value.to_string()); self } @@ -41901,7 +41897,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Allows searching for objects by name or ID. Wildcards (*) are allowed. For example, "creative*2015" will return objects with names like "creative June 2015", "creative April 2015", or simply "creative 2015". Most of the searches also add wildcards implicitly at the start and the end of the search string. For example, a search string of "creative" will match objects with name "my creative", "creative 2015", or simply "creative". - pub fn search_string(mut self, new_value: &str) -> CreativeListCall<'a, C, NC, A> { + pub fn search_string(mut self, new_value: &str) -> CreativeListCall<'a, C, A> { self._search_string = Some(new_value.to_string()); self } @@ -41910,7 +41906,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only creatives with these rendering IDs. - pub fn add_rendering_ids(mut self, new_value: &str) -> CreativeListCall<'a, C, NC, A> { + pub fn add_rendering_ids(mut self, new_value: &str) -> CreativeListCall<'a, C, A> { self._rendering_ids.push(new_value.to_string()); self } @@ -41918,7 +41914,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Value of the nextPageToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> CreativeListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> CreativeListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -41926,7 +41922,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> CreativeListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> CreativeListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -41935,7 +41931,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only creatives with these IDs. - pub fn add_ids(mut self, new_value: &str) -> CreativeListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> CreativeListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -41944,7 +41940,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only creatives with these creative field IDs. - pub fn add_creative_field_ids(mut self, new_value: &str) -> CreativeListCall<'a, C, NC, A> { + pub fn add_creative_field_ids(mut self, new_value: &str) -> CreativeListCall<'a, C, A> { self._creative_field_ids.push(new_value.to_string()); self } @@ -41953,7 +41949,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only in-stream video creatives with these companion IDs. - pub fn add_companion_creative_ids(mut self, new_value: &str) -> CreativeListCall<'a, C, NC, A> { + pub fn add_companion_creative_ids(mut self, new_value: &str) -> CreativeListCall<'a, C, A> { self._companion_creative_ids.push(new_value.to_string()); self } @@ -41961,7 +41957,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only creatives with this campaign ID. - pub fn campaign_id(mut self, new_value: &str) -> CreativeListCall<'a, C, NC, A> { + pub fn campaign_id(mut self, new_value: &str) -> CreativeListCall<'a, C, A> { self._campaign_id = Some(new_value.to_string()); self } @@ -41969,7 +41965,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only archived creatives. Leave blank to select archived and unarchived creatives. - pub fn archived(mut self, new_value: bool) -> CreativeListCall<'a, C, NC, A> { + pub fn archived(mut self, new_value: bool) -> CreativeListCall<'a, C, A> { self._archived = Some(new_value); self } @@ -41977,7 +41973,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only creatives with this advertiser ID. - pub fn advertiser_id(mut self, new_value: &str) -> CreativeListCall<'a, C, NC, A> { + pub fn advertiser_id(mut self, new_value: &str) -> CreativeListCall<'a, C, A> { self._advertiser_id = Some(new_value.to_string()); self } @@ -41985,7 +41981,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only active creatives. Leave blank to select active and inactive creatives. - pub fn active(mut self, new_value: bool) -> CreativeListCall<'a, C, NC, A> { + pub fn active(mut self, new_value: bool) -> CreativeListCall<'a, C, A> { self._active = Some(new_value); self } @@ -41996,7 +41992,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -42017,7 +42013,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -42034,7 +42030,7 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -42078,10 +42074,10 @@ impl<'a, C, NC, A> CreativeListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct CreativePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Creative, _profile_id: String, _id: String, @@ -42090,9 +42086,9 @@ pub struct CreativePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativePatchCall<'a, C, A> {} -impl<'a, C, NC, A> CreativePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -42232,7 +42228,7 @@ impl<'a, C, NC, A> CreativePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Creative) -> CreativePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Creative) -> CreativePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -42242,7 +42238,7 @@ impl<'a, C, NC, A> CreativePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CreativePatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CreativePatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -42252,7 +42248,7 @@ impl<'a, C, NC, A> CreativePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Creative ID. - pub fn id(mut self, new_value: &str) -> CreativePatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> CreativePatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -42263,7 +42259,7 @@ impl<'a, C, NC, A> CreativePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -42284,7 +42280,7 @@ impl<'a, C, NC, A> CreativePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -42301,7 +42297,7 @@ impl<'a, C, NC, A> CreativePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -42339,10 +42335,10 @@ impl<'a, C, NC, A> CreativePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct CampaignGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CampaignGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -42350,9 +42346,9 @@ pub struct CampaignGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CampaignGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CampaignGetCall<'a, C, A> {} -impl<'a, C, NC, A> CampaignGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CampaignGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -42485,7 +42481,7 @@ impl<'a, C, NC, A> CampaignGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CampaignGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CampaignGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -42495,7 +42491,7 @@ impl<'a, C, NC, A> CampaignGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Campaign ID. - pub fn id(mut self, new_value: &str) -> CampaignGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> CampaignGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -42506,7 +42502,7 @@ impl<'a, C, NC, A> CampaignGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CampaignGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CampaignGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -42527,7 +42523,7 @@ impl<'a, C, NC, A> CampaignGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CampaignGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CampaignGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -42544,7 +42540,7 @@ impl<'a, C, NC, A> CampaignGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CampaignGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CampaignGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -42588,10 +42584,10 @@ impl<'a, C, NC, A> CampaignGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct CampaignInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CampaignInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Campaign, _profile_id: String, _default_landing_page_name: String, @@ -42601,9 +42597,9 @@ pub struct CampaignInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CampaignInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CampaignInsertCall<'a, C, A> {} -impl<'a, C, NC, A> CampaignInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CampaignInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -42744,7 +42740,7 @@ impl<'a, C, NC, A> CampaignInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Campaign) -> CampaignInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Campaign) -> CampaignInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -42754,7 +42750,7 @@ impl<'a, C, NC, A> CampaignInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CampaignInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CampaignInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -42764,7 +42760,7 @@ impl<'a, C, NC, A> CampaignInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Default landing page name for this new campaign. Must be less than 256 characters long. - pub fn default_landing_page_name(mut self, new_value: &str) -> CampaignInsertCall<'a, C, NC, A> { + pub fn default_landing_page_name(mut self, new_value: &str) -> CampaignInsertCall<'a, C, A> { self._default_landing_page_name = new_value.to_string(); self } @@ -42774,7 +42770,7 @@ impl<'a, C, NC, A> CampaignInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Default landing page URL for this new campaign. - pub fn default_landing_page_url(mut self, new_value: &str) -> CampaignInsertCall<'a, C, NC, A> { + pub fn default_landing_page_url(mut self, new_value: &str) -> CampaignInsertCall<'a, C, A> { self._default_landing_page_url = new_value.to_string(); self } @@ -42785,7 +42781,7 @@ impl<'a, C, NC, A> CampaignInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CampaignInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CampaignInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -42806,7 +42802,7 @@ impl<'a, C, NC, A> CampaignInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CampaignInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CampaignInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -42823,7 +42819,7 @@ impl<'a, C, NC, A> CampaignInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CampaignInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CampaignInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -42867,10 +42863,10 @@ impl<'a, C, NC, A> CampaignInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct CampaignPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CampaignPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Campaign, _profile_id: String, _id: String, @@ -42879,9 +42875,9 @@ pub struct CampaignPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CampaignPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CampaignPatchCall<'a, C, A> {} -impl<'a, C, NC, A> CampaignPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CampaignPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -43021,7 +43017,7 @@ impl<'a, C, NC, A> CampaignPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Campaign) -> CampaignPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Campaign) -> CampaignPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -43031,7 +43027,7 @@ impl<'a, C, NC, A> CampaignPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CampaignPatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CampaignPatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -43041,7 +43037,7 @@ impl<'a, C, NC, A> CampaignPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Campaign ID. - pub fn id(mut self, new_value: &str) -> CampaignPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> CampaignPatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -43052,7 +43048,7 @@ impl<'a, C, NC, A> CampaignPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CampaignPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CampaignPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -43073,7 +43069,7 @@ impl<'a, C, NC, A> CampaignPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CampaignPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CampaignPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -43090,7 +43086,7 @@ impl<'a, C, NC, A> CampaignPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CampaignPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CampaignPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -43134,10 +43130,10 @@ impl<'a, C, NC, A> CampaignPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct CampaignUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CampaignUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Campaign, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -43145,9 +43141,9 @@ pub struct CampaignUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CampaignUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CampaignUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> CampaignUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CampaignUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -43286,7 +43282,7 @@ impl<'a, C, NC, A> CampaignUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Campaign) -> CampaignUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Campaign) -> CampaignUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -43296,7 +43292,7 @@ impl<'a, C, NC, A> CampaignUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CampaignUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CampaignUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -43307,7 +43303,7 @@ impl<'a, C, NC, A> CampaignUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CampaignUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CampaignUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -43328,7 +43324,7 @@ impl<'a, C, NC, A> CampaignUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CampaignUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CampaignUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -43345,7 +43341,7 @@ impl<'a, C, NC, A> CampaignUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CampaignUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CampaignUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -43396,10 +43392,10 @@ impl<'a, C, NC, A> CampaignUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct CampaignListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CampaignListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _subaccount_id: Option, _sort_order: Option, @@ -43419,9 +43415,9 @@ pub struct CampaignListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CampaignListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CampaignListCall<'a, C, A> {} -impl<'a, C, NC, A> CampaignListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CampaignListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -43608,7 +43604,7 @@ impl<'a, C, NC, A> CampaignListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CampaignListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CampaignListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -43616,7 +43612,7 @@ impl<'a, C, NC, A> CampaignListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only campaigns that belong to this subaccount. - pub fn subaccount_id(mut self, new_value: &str) -> CampaignListCall<'a, C, NC, A> { + pub fn subaccount_id(mut self, new_value: &str) -> CampaignListCall<'a, C, A> { self._subaccount_id = Some(new_value.to_string()); self } @@ -43624,7 +43620,7 @@ impl<'a, C, NC, A> CampaignListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Order of sorted results, default is ASCENDING. - pub fn sort_order(mut self, new_value: &str) -> CampaignListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> CampaignListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -43632,7 +43628,7 @@ impl<'a, C, NC, A> CampaignListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> CampaignListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> CampaignListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -43640,7 +43636,7 @@ impl<'a, C, NC, A> CampaignListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Allows searching for campaigns by name or ID. Wildcards (*) are allowed. For example, "campaign*2015" will return campaigns with names like "campaign June 2015", "campaign April 2015", or simply "campaign 2015". Most of the searches also add wildcards implicitly at the start and the end of the search string. For example, a search string of "campaign" will match campaigns with name "my campaign", "campaign 2015", or simply "campaign". - pub fn search_string(mut self, new_value: &str) -> CampaignListCall<'a, C, NC, A> { + pub fn search_string(mut self, new_value: &str) -> CampaignListCall<'a, C, A> { self._search_string = Some(new_value.to_string()); self } @@ -43648,7 +43644,7 @@ impl<'a, C, NC, A> CampaignListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Value of the nextPageToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> CampaignListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> CampaignListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -43656,7 +43652,7 @@ impl<'a, C, NC, A> CampaignListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only campaigns that have overridden this event tag ID. - pub fn overridden_event_tag_id(mut self, new_value: &str) -> CampaignListCall<'a, C, NC, A> { + pub fn overridden_event_tag_id(mut self, new_value: &str) -> CampaignListCall<'a, C, A> { self._overridden_event_tag_id = Some(new_value.to_string()); self } @@ -43664,7 +43660,7 @@ impl<'a, C, NC, A> CampaignListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> CampaignListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> CampaignListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -43673,7 +43669,7 @@ impl<'a, C, NC, A> CampaignListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only campaigns with these IDs. - pub fn add_ids(mut self, new_value: &str) -> CampaignListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> CampaignListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -43682,7 +43678,7 @@ impl<'a, C, NC, A> CampaignListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Exclude campaigns with these IDs. - pub fn add_excluded_ids(mut self, new_value: &str) -> CampaignListCall<'a, C, NC, A> { + pub fn add_excluded_ids(mut self, new_value: &str) -> CampaignListCall<'a, C, A> { self._excluded_ids.push(new_value.to_string()); self } @@ -43690,7 +43686,7 @@ impl<'a, C, NC, A> CampaignListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only campaigns that have at least one optimization activity. - pub fn at_least_one_optimization_activity(mut self, new_value: bool) -> CampaignListCall<'a, C, NC, A> { + pub fn at_least_one_optimization_activity(mut self, new_value: bool) -> CampaignListCall<'a, C, A> { self._at_least_one_optimization_activity = Some(new_value); self } @@ -43698,7 +43694,7 @@ impl<'a, C, NC, A> CampaignListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only archived campaigns. Don't set this field to select both archived and non-archived campaigns. - pub fn archived(mut self, new_value: bool) -> CampaignListCall<'a, C, NC, A> { + pub fn archived(mut self, new_value: bool) -> CampaignListCall<'a, C, A> { self._archived = Some(new_value); self } @@ -43707,7 +43703,7 @@ impl<'a, C, NC, A> CampaignListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only campaigns that belong to these advertisers. - pub fn add_advertiser_ids(mut self, new_value: &str) -> CampaignListCall<'a, C, NC, A> { + pub fn add_advertiser_ids(mut self, new_value: &str) -> CampaignListCall<'a, C, A> { self._advertiser_ids.push(new_value.to_string()); self } @@ -43716,7 +43712,7 @@ impl<'a, C, NC, A> CampaignListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only campaigns whose advertisers belong to these advertiser groups. - pub fn add_advertiser_group_ids(mut self, new_value: &str) -> CampaignListCall<'a, C, NC, A> { + pub fn add_advertiser_group_ids(mut self, new_value: &str) -> CampaignListCall<'a, C, A> { self._advertiser_group_ids.push(new_value.to_string()); self } @@ -43727,7 +43723,7 @@ impl<'a, C, NC, A> CampaignListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CampaignListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CampaignListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -43748,7 +43744,7 @@ impl<'a, C, NC, A> CampaignListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CampaignListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CampaignListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -43765,7 +43761,7 @@ impl<'a, C, NC, A> CampaignListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CampaignListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CampaignListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -43803,10 +43799,10 @@ impl<'a, C, NC, A> CampaignListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct EventTagDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventTagDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -43814,9 +43810,9 @@ pub struct EventTagDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventTagDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventTagDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> EventTagDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventTagDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -43938,7 +43934,7 @@ impl<'a, C, NC, A> EventTagDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> EventTagDeleteCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> EventTagDeleteCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -43948,7 +43944,7 @@ impl<'a, C, NC, A> EventTagDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Event tag ID. - pub fn id(mut self, new_value: &str) -> EventTagDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> EventTagDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -43959,7 +43955,7 @@ impl<'a, C, NC, A> EventTagDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventTagDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventTagDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -43980,7 +43976,7 @@ impl<'a, C, NC, A> EventTagDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventTagDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventTagDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -43997,7 +43993,7 @@ impl<'a, C, NC, A> EventTagDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventTagDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventTagDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -44045,10 +44041,10 @@ impl<'a, C, NC, A> EventTagDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct EventTagListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventTagListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _sort_order: Option, _sort_field: Option, @@ -44065,9 +44061,9 @@ pub struct EventTagListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventTagListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventTagListCall<'a, C, A> {} -impl<'a, C, NC, A> EventTagListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventTagListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -44237,7 +44233,7 @@ impl<'a, C, NC, A> EventTagListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> EventTagListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> EventTagListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -44245,7 +44241,7 @@ impl<'a, C, NC, A> EventTagListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Order of sorted results, default is ASCENDING. - pub fn sort_order(mut self, new_value: &str) -> EventTagListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> EventTagListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -44253,7 +44249,7 @@ impl<'a, C, NC, A> EventTagListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> EventTagListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> EventTagListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -44261,7 +44257,7 @@ impl<'a, C, NC, A> EventTagListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Allows searching for objects by name or ID. Wildcards (*) are allowed. For example, "eventtag*2015" will return objects with names like "eventtag June 2015", "eventtag April 2015", or simply "eventtag 2015". Most of the searches also add wildcards implicitly at the start and the end of the search string. For example, a search string of "eventtag" will match objects with name "my eventtag", "eventtag 2015", or simply "eventtag". - pub fn search_string(mut self, new_value: &str) -> EventTagListCall<'a, C, NC, A> { + pub fn search_string(mut self, new_value: &str) -> EventTagListCall<'a, C, A> { self._search_string = Some(new_value.to_string()); self } @@ -44270,7 +44266,7 @@ impl<'a, C, NC, A> EventTagListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only event tags with these IDs. - pub fn add_ids(mut self, new_value: &str) -> EventTagListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> EventTagListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -44279,7 +44275,7 @@ impl<'a, C, NC, A> EventTagListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only event tags with the specified event tag types. Event tag types can be used to specify whether to use a third-party pixel, a third-party JavaScript URL, or a third-party click-through URL for either impression or click tracking. - pub fn add_event_tag_types(mut self, new_value: &str) -> EventTagListCall<'a, C, NC, A> { + pub fn add_event_tag_types(mut self, new_value: &str) -> EventTagListCall<'a, C, A> { self._event_tag_types.push(new_value.to_string()); self } @@ -44287,7 +44283,7 @@ impl<'a, C, NC, A> EventTagListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only enabled event tags. When definitionsOnly is set to true, only the specified advertiser or campaign's event tags' enabledByDefault field is examined. When definitionsOnly is set to false, the specified ad or specified campaign's parent advertiser's or parent campaign's event tags' enabledByDefault and status fields are examined as well. - pub fn enabled(mut self, new_value: bool) -> EventTagListCall<'a, C, NC, A> { + pub fn enabled(mut self, new_value: bool) -> EventTagListCall<'a, C, A> { self._enabled = Some(new_value); self } @@ -44295,7 +44291,7 @@ impl<'a, C, NC, A> EventTagListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Examine only the specified ad or campaign or advertiser's event tags for matching selector criteria. When set to false, the parent advertiser and parent campaign is examined as well. In addition, when set to false, the status field is examined as well along with the enabledByDefault field. - pub fn definitions_only(mut self, new_value: bool) -> EventTagListCall<'a, C, NC, A> { + pub fn definitions_only(mut self, new_value: bool) -> EventTagListCall<'a, C, A> { self._definitions_only = Some(new_value); self } @@ -44303,7 +44299,7 @@ impl<'a, C, NC, A> EventTagListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only event tags that belong to this campaign. - pub fn campaign_id(mut self, new_value: &str) -> EventTagListCall<'a, C, NC, A> { + pub fn campaign_id(mut self, new_value: &str) -> EventTagListCall<'a, C, A> { self._campaign_id = Some(new_value.to_string()); self } @@ -44311,7 +44307,7 @@ impl<'a, C, NC, A> EventTagListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only event tags that belong to this advertiser. - pub fn advertiser_id(mut self, new_value: &str) -> EventTagListCall<'a, C, NC, A> { + pub fn advertiser_id(mut self, new_value: &str) -> EventTagListCall<'a, C, A> { self._advertiser_id = Some(new_value.to_string()); self } @@ -44319,7 +44315,7 @@ impl<'a, C, NC, A> EventTagListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Select only event tags that belong to this ad. - pub fn ad_id(mut self, new_value: &str) -> EventTagListCall<'a, C, NC, A> { + pub fn ad_id(mut self, new_value: &str) -> EventTagListCall<'a, C, A> { self._ad_id = Some(new_value.to_string()); self } @@ -44330,7 +44326,7 @@ impl<'a, C, NC, A> EventTagListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventTagListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventTagListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -44351,7 +44347,7 @@ impl<'a, C, NC, A> EventTagListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventTagListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventTagListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -44368,7 +44364,7 @@ impl<'a, C, NC, A> EventTagListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventTagListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventTagListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -44412,10 +44408,10 @@ impl<'a, C, NC, A> EventTagListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct EventTagInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventTagInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: EventTag, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -44423,9 +44419,9 @@ pub struct EventTagInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventTagInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventTagInsertCall<'a, C, A> {} -impl<'a, C, NC, A> EventTagInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventTagInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -44564,7 +44560,7 @@ impl<'a, C, NC, A> EventTagInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &EventTag) -> EventTagInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &EventTag) -> EventTagInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -44574,7 +44570,7 @@ impl<'a, C, NC, A> EventTagInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> EventTagInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> EventTagInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -44585,7 +44581,7 @@ impl<'a, C, NC, A> EventTagInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventTagInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventTagInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -44606,7 +44602,7 @@ impl<'a, C, NC, A> EventTagInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventTagInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventTagInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -44623,7 +44619,7 @@ impl<'a, C, NC, A> EventTagInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventTagInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventTagInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -44667,10 +44663,10 @@ impl<'a, C, NC, A> EventTagInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct EventTagPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventTagPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: EventTag, _profile_id: String, _id: String, @@ -44679,9 +44675,9 @@ pub struct EventTagPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventTagPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventTagPatchCall<'a, C, A> {} -impl<'a, C, NC, A> EventTagPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventTagPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -44821,7 +44817,7 @@ impl<'a, C, NC, A> EventTagPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &EventTag) -> EventTagPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &EventTag) -> EventTagPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -44831,7 +44827,7 @@ impl<'a, C, NC, A> EventTagPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> EventTagPatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> EventTagPatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -44841,7 +44837,7 @@ impl<'a, C, NC, A> EventTagPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Event tag ID. - pub fn id(mut self, new_value: &str) -> EventTagPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> EventTagPatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -44852,7 +44848,7 @@ impl<'a, C, NC, A> EventTagPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventTagPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventTagPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -44873,7 +44869,7 @@ impl<'a, C, NC, A> EventTagPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventTagPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventTagPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -44890,7 +44886,7 @@ impl<'a, C, NC, A> EventTagPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventTagPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventTagPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -44934,10 +44930,10 @@ impl<'a, C, NC, A> EventTagPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct EventTagUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventTagUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: EventTag, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -44945,9 +44941,9 @@ pub struct EventTagUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventTagUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventTagUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> EventTagUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventTagUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -45086,7 +45082,7 @@ impl<'a, C, NC, A> EventTagUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &EventTag) -> EventTagUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &EventTag) -> EventTagUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -45096,7 +45092,7 @@ impl<'a, C, NC, A> EventTagUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> EventTagUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> EventTagUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -45107,7 +45103,7 @@ impl<'a, C, NC, A> EventTagUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventTagUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventTagUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -45128,7 +45124,7 @@ impl<'a, C, NC, A> EventTagUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventTagUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventTagUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -45145,7 +45141,7 @@ impl<'a, C, NC, A> EventTagUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventTagUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventTagUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -45183,10 +45179,10 @@ impl<'a, C, NC, A> EventTagUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct EventTagGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventTagGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -45194,9 +45190,9 @@ pub struct EventTagGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventTagGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventTagGetCall<'a, C, A> {} -impl<'a, C, NC, A> EventTagGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventTagGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -45329,7 +45325,7 @@ impl<'a, C, NC, A> EventTagGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> EventTagGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> EventTagGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -45339,7 +45335,7 @@ impl<'a, C, NC, A> EventTagGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Event tag ID. - pub fn id(mut self, new_value: &str) -> EventTagGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> EventTagGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -45350,7 +45346,7 @@ impl<'a, C, NC, A> EventTagGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventTagGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventTagGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -45371,7 +45367,7 @@ impl<'a, C, NC, A> EventTagGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventTagGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventTagGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -45388,7 +45384,7 @@ impl<'a, C, NC, A> EventTagGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventTagGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventTagGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -45430,10 +45426,10 @@ impl<'a, C, NC, A> EventTagGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct CityListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CityListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _region_dart_ids: Vec, _name_prefix: Option, @@ -45444,9 +45440,9 @@ pub struct CityListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CityListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CityListCall<'a, C, A> {} -impl<'a, C, NC, A> CityListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CityListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -45602,7 +45598,7 @@ impl<'a, C, NC, A> CityListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CityListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CityListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -45611,7 +45607,7 @@ impl<'a, C, NC, A> CityListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Select only cities from these regions. - pub fn add_region_dart_ids(mut self, new_value: &str) -> CityListCall<'a, C, NC, A> { + pub fn add_region_dart_ids(mut self, new_value: &str) -> CityListCall<'a, C, A> { self._region_dart_ids.push(new_value.to_string()); self } @@ -45619,7 +45615,7 @@ impl<'a, C, NC, A> CityListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Select only cities with names starting with this prefix. - pub fn name_prefix(mut self, new_value: &str) -> CityListCall<'a, C, NC, A> { + pub fn name_prefix(mut self, new_value: &str) -> CityListCall<'a, C, A> { self._name_prefix = Some(new_value.to_string()); self } @@ -45628,7 +45624,7 @@ impl<'a, C, NC, A> CityListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Select only cities with these DART IDs. - pub fn add_dart_ids(mut self, new_value: &str) -> CityListCall<'a, C, NC, A> { + pub fn add_dart_ids(mut self, new_value: &str) -> CityListCall<'a, C, A> { self._dart_ids.push(new_value.to_string()); self } @@ -45637,7 +45633,7 @@ impl<'a, C, NC, A> CityListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Select only cities from these countries. - pub fn add_country_dart_ids(mut self, new_value: &str) -> CityListCall<'a, C, NC, A> { + pub fn add_country_dart_ids(mut self, new_value: &str) -> CityListCall<'a, C, A> { self._country_dart_ids.push(new_value.to_string()); self } @@ -45648,7 +45644,7 @@ impl<'a, C, NC, A> CityListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CityListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CityListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -45669,7 +45665,7 @@ impl<'a, C, NC, A> CityListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CityListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CityListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -45686,7 +45682,7 @@ impl<'a, C, NC, A> CityListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CityListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CityListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -45730,10 +45726,10 @@ impl<'a, C, NC, A> CityListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct PlacementStrategyListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlacementStrategyListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _sort_order: Option, _sort_field: Option, @@ -45746,9 +45742,9 @@ pub struct PlacementStrategyListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlacementStrategyListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlacementStrategyListCall<'a, C, A> {} -impl<'a, C, NC, A> PlacementStrategyListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlacementStrategyListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -45902,7 +45898,7 @@ impl<'a, C, NC, A> PlacementStrategyListCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> PlacementStrategyListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> PlacementStrategyListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -45910,7 +45906,7 @@ impl<'a, C, NC, A> PlacementStrategyListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Order of sorted results, default is ASCENDING. - pub fn sort_order(mut self, new_value: &str) -> PlacementStrategyListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> PlacementStrategyListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -45918,7 +45914,7 @@ impl<'a, C, NC, A> PlacementStrategyListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> PlacementStrategyListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> PlacementStrategyListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -45926,7 +45922,7 @@ impl<'a, C, NC, A> PlacementStrategyListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Allows searching for objects by name or ID. Wildcards (*) are allowed. For example, "placementstrategy*2015" will return objects with names like "placementstrategy June 2015", "placementstrategy April 2015", or simply "placementstrategy 2015". Most of the searches also add wildcards implicitly at the start and the end of the search string. For example, a search string of "placementstrategy" will match objects with name "my placementstrategy", "placementstrategy 2015", or simply "placementstrategy". - pub fn search_string(mut self, new_value: &str) -> PlacementStrategyListCall<'a, C, NC, A> { + pub fn search_string(mut self, new_value: &str) -> PlacementStrategyListCall<'a, C, A> { self._search_string = Some(new_value.to_string()); self } @@ -45934,7 +45930,7 @@ impl<'a, C, NC, A> PlacementStrategyListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Value of the nextPageToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> PlacementStrategyListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> PlacementStrategyListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -45942,7 +45938,7 @@ impl<'a, C, NC, A> PlacementStrategyListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> PlacementStrategyListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> PlacementStrategyListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -45951,7 +45947,7 @@ impl<'a, C, NC, A> PlacementStrategyListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Select only placement strategies with these IDs. - pub fn add_ids(mut self, new_value: &str) -> PlacementStrategyListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> PlacementStrategyListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -45962,7 +45958,7 @@ impl<'a, C, NC, A> PlacementStrategyListCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementStrategyListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementStrategyListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -45983,7 +45979,7 @@ impl<'a, C, NC, A> PlacementStrategyListCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlacementStrategyListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlacementStrategyListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -46000,7 +45996,7 @@ impl<'a, C, NC, A> PlacementStrategyListCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlacementStrategyListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlacementStrategyListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -46044,10 +46040,10 @@ impl<'a, C, NC, A> PlacementStrategyListCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct PlacementStrategyUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlacementStrategyUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: PlacementStrategy, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -46055,9 +46051,9 @@ pub struct PlacementStrategyUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlacementStrategyUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlacementStrategyUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> PlacementStrategyUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlacementStrategyUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -46196,7 +46192,7 @@ impl<'a, C, NC, A> PlacementStrategyUpdateCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PlacementStrategy) -> PlacementStrategyUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PlacementStrategy) -> PlacementStrategyUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -46206,7 +46202,7 @@ impl<'a, C, NC, A> PlacementStrategyUpdateCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> PlacementStrategyUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> PlacementStrategyUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -46217,7 +46213,7 @@ impl<'a, C, NC, A> PlacementStrategyUpdateCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementStrategyUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementStrategyUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -46238,7 +46234,7 @@ impl<'a, C, NC, A> PlacementStrategyUpdateCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlacementStrategyUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlacementStrategyUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -46255,7 +46251,7 @@ impl<'a, C, NC, A> PlacementStrategyUpdateCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlacementStrategyUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlacementStrategyUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -46293,10 +46289,10 @@ impl<'a, C, NC, A> PlacementStrategyUpdateCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct PlacementStrategyGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlacementStrategyGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -46304,9 +46300,9 @@ pub struct PlacementStrategyGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlacementStrategyGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlacementStrategyGetCall<'a, C, A> {} -impl<'a, C, NC, A> PlacementStrategyGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlacementStrategyGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -46439,7 +46435,7 @@ impl<'a, C, NC, A> PlacementStrategyGetCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> PlacementStrategyGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> PlacementStrategyGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -46449,7 +46445,7 @@ impl<'a, C, NC, A> PlacementStrategyGetCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Placement strategy ID. - pub fn id(mut self, new_value: &str) -> PlacementStrategyGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> PlacementStrategyGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -46460,7 +46456,7 @@ impl<'a, C, NC, A> PlacementStrategyGetCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementStrategyGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementStrategyGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -46481,7 +46477,7 @@ impl<'a, C, NC, A> PlacementStrategyGetCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlacementStrategyGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlacementStrategyGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -46498,7 +46494,7 @@ impl<'a, C, NC, A> PlacementStrategyGetCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlacementStrategyGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlacementStrategyGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -46536,10 +46532,10 @@ impl<'a, C, NC, A> PlacementStrategyGetCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct PlacementStrategyDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlacementStrategyDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -46547,9 +46543,9 @@ pub struct PlacementStrategyDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlacementStrategyDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlacementStrategyDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> PlacementStrategyDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlacementStrategyDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -46671,7 +46667,7 @@ impl<'a, C, NC, A> PlacementStrategyDeleteCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> PlacementStrategyDeleteCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> PlacementStrategyDeleteCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -46681,7 +46677,7 @@ impl<'a, C, NC, A> PlacementStrategyDeleteCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Placement strategy ID. - pub fn id(mut self, new_value: &str) -> PlacementStrategyDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> PlacementStrategyDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -46692,7 +46688,7 @@ impl<'a, C, NC, A> PlacementStrategyDeleteCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementStrategyDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementStrategyDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -46713,7 +46709,7 @@ impl<'a, C, NC, A> PlacementStrategyDeleteCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlacementStrategyDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlacementStrategyDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -46730,7 +46726,7 @@ impl<'a, C, NC, A> PlacementStrategyDeleteCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlacementStrategyDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlacementStrategyDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -46774,10 +46770,10 @@ impl<'a, C, NC, A> PlacementStrategyDeleteCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct PlacementStrategyInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlacementStrategyInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: PlacementStrategy, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -46785,9 +46781,9 @@ pub struct PlacementStrategyInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlacementStrategyInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlacementStrategyInsertCall<'a, C, A> {} -impl<'a, C, NC, A> PlacementStrategyInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlacementStrategyInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -46926,7 +46922,7 @@ impl<'a, C, NC, A> PlacementStrategyInsertCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PlacementStrategy) -> PlacementStrategyInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PlacementStrategy) -> PlacementStrategyInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -46936,7 +46932,7 @@ impl<'a, C, NC, A> PlacementStrategyInsertCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> PlacementStrategyInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> PlacementStrategyInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -46947,7 +46943,7 @@ impl<'a, C, NC, A> PlacementStrategyInsertCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementStrategyInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementStrategyInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -46968,7 +46964,7 @@ impl<'a, C, NC, A> PlacementStrategyInsertCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlacementStrategyInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlacementStrategyInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -46985,7 +46981,7 @@ impl<'a, C, NC, A> PlacementStrategyInsertCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlacementStrategyInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlacementStrategyInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -47029,10 +47025,10 @@ impl<'a, C, NC, A> PlacementStrategyInsertCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct PlacementStrategyPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlacementStrategyPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: PlacementStrategy, _profile_id: String, _id: String, @@ -47041,9 +47037,9 @@ pub struct PlacementStrategyPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlacementStrategyPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlacementStrategyPatchCall<'a, C, A> {} -impl<'a, C, NC, A> PlacementStrategyPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlacementStrategyPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -47183,7 +47179,7 @@ impl<'a, C, NC, A> PlacementStrategyPatchCall<'a, C, NC, A> where NC: hyper::net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PlacementStrategy) -> PlacementStrategyPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PlacementStrategy) -> PlacementStrategyPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -47193,7 +47189,7 @@ impl<'a, C, NC, A> PlacementStrategyPatchCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> PlacementStrategyPatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> PlacementStrategyPatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -47203,7 +47199,7 @@ impl<'a, C, NC, A> PlacementStrategyPatchCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Placement strategy ID. - pub fn id(mut self, new_value: &str) -> PlacementStrategyPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> PlacementStrategyPatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -47214,7 +47210,7 @@ impl<'a, C, NC, A> PlacementStrategyPatchCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementStrategyPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementStrategyPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -47235,7 +47231,7 @@ impl<'a, C, NC, A> PlacementStrategyPatchCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlacementStrategyPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlacementStrategyPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -47252,7 +47248,7 @@ impl<'a, C, NC, A> PlacementStrategyPatchCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlacementStrategyPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlacementStrategyPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -47303,10 +47299,10 @@ impl<'a, C, NC, A> PlacementStrategyPatchCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct DirectorySiteListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DirectorySiteListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _sort_order: Option, _sort_field: Option, @@ -47326,9 +47322,9 @@ pub struct DirectorySiteListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DirectorySiteListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DirectorySiteListCall<'a, C, A> {} -impl<'a, C, NC, A> DirectorySiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DirectorySiteListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -47503,7 +47499,7 @@ impl<'a, C, NC, A> DirectorySiteListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> DirectorySiteListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> DirectorySiteListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -47511,7 +47507,7 @@ impl<'a, C, NC, A> DirectorySiteListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Order of sorted results, default is ASCENDING. - pub fn sort_order(mut self, new_value: &str) -> DirectorySiteListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> DirectorySiteListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -47519,7 +47515,7 @@ impl<'a, C, NC, A> DirectorySiteListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> DirectorySiteListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> DirectorySiteListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -47527,7 +47523,7 @@ impl<'a, C, NC, A> DirectorySiteListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Allows searching for objects by name, ID or URL. Wildcards (*) are allowed. For example, "directory site*2015" will return objects with names like "directory site June 2015", "directory site April 2015", or simply "directory site 2015". Most of the searches also add wildcards implicitly at the start and the end of the search string. For example, a search string of "directory site" will match objects with name "my directory site", "directory site 2015" or simply, "directory site". - pub fn search_string(mut self, new_value: &str) -> DirectorySiteListCall<'a, C, NC, A> { + pub fn search_string(mut self, new_value: &str) -> DirectorySiteListCall<'a, C, A> { self._search_string = Some(new_value.to_string()); self } @@ -47535,7 +47531,7 @@ impl<'a, C, NC, A> DirectorySiteListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Select only directory sites with this parent ID. - pub fn parent_id(mut self, new_value: &str) -> DirectorySiteListCall<'a, C, NC, A> { + pub fn parent_id(mut self, new_value: &str) -> DirectorySiteListCall<'a, C, A> { self._parent_id = Some(new_value.to_string()); self } @@ -47543,7 +47539,7 @@ impl<'a, C, NC, A> DirectorySiteListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Value of the nextPageToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> DirectorySiteListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> DirectorySiteListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -47551,7 +47547,7 @@ impl<'a, C, NC, A> DirectorySiteListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> DirectorySiteListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> DirectorySiteListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -47560,7 +47556,7 @@ impl<'a, C, NC, A> DirectorySiteListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Select only directory sites with these IDs. - pub fn add_ids(mut self, new_value: &str) -> DirectorySiteListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> DirectorySiteListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -47568,7 +47564,7 @@ impl<'a, C, NC, A> DirectorySiteListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Select only directory sites with this DFP network code. - pub fn dfp_network_code(mut self, new_value: &str) -> DirectorySiteListCall<'a, C, NC, A> { + pub fn dfp_network_code(mut self, new_value: &str) -> DirectorySiteListCall<'a, C, A> { self._dfp_network_code = Some(new_value.to_string()); self } @@ -47576,7 +47572,7 @@ impl<'a, C, NC, A> DirectorySiteListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Select only directory sites with this country ID. - pub fn country_id(mut self, new_value: &str) -> DirectorySiteListCall<'a, C, NC, A> { + pub fn country_id(mut self, new_value: &str) -> DirectorySiteListCall<'a, C, A> { self._country_id = Some(new_value.to_string()); self } @@ -47584,7 +47580,7 @@ impl<'a, C, NC, A> DirectorySiteListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Select only active directory sites. Leave blank to retrieve both active and inactive directory sites. - pub fn active(mut self, new_value: bool) -> DirectorySiteListCall<'a, C, NC, A> { + pub fn active(mut self, new_value: bool) -> DirectorySiteListCall<'a, C, A> { self._active = Some(new_value); self } @@ -47592,7 +47588,7 @@ impl<'a, C, NC, A> DirectorySiteListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Select only directory sites that accept publisher paid placements. This field can be left blank. - pub fn accepts_publisher_paid_placements(mut self, new_value: bool) -> DirectorySiteListCall<'a, C, NC, A> { + pub fn accepts_publisher_paid_placements(mut self, new_value: bool) -> DirectorySiteListCall<'a, C, A> { self._accepts_publisher_paid_placements = Some(new_value); self } @@ -47600,7 +47596,7 @@ impl<'a, C, NC, A> DirectorySiteListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// This search filter is no longer supported and will have no effect on the results returned. - pub fn accepts_interstitial_placements(mut self, new_value: bool) -> DirectorySiteListCall<'a, C, NC, A> { + pub fn accepts_interstitial_placements(mut self, new_value: bool) -> DirectorySiteListCall<'a, C, A> { self._accepts_interstitial_placements = Some(new_value); self } @@ -47608,7 +47604,7 @@ impl<'a, C, NC, A> DirectorySiteListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// This search filter is no longer supported and will have no effect on the results returned. - pub fn accepts_in_stream_video_placements(mut self, new_value: bool) -> DirectorySiteListCall<'a, C, NC, A> { + pub fn accepts_in_stream_video_placements(mut self, new_value: bool) -> DirectorySiteListCall<'a, C, A> { self._accepts_in_stream_video_placements = Some(new_value); self } @@ -47619,7 +47615,7 @@ impl<'a, C, NC, A> DirectorySiteListCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DirectorySiteListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DirectorySiteListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -47640,7 +47636,7 @@ impl<'a, C, NC, A> DirectorySiteListCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DirectorySiteListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DirectorySiteListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -47657,7 +47653,7 @@ impl<'a, C, NC, A> DirectorySiteListCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DirectorySiteListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DirectorySiteListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -47695,10 +47691,10 @@ impl<'a, C, NC, A> DirectorySiteListCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct DirectorySiteGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DirectorySiteGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -47706,9 +47702,9 @@ pub struct DirectorySiteGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DirectorySiteGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DirectorySiteGetCall<'a, C, A> {} -impl<'a, C, NC, A> DirectorySiteGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DirectorySiteGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -47841,7 +47837,7 @@ impl<'a, C, NC, A> DirectorySiteGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> DirectorySiteGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> DirectorySiteGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -47851,7 +47847,7 @@ impl<'a, C, NC, A> DirectorySiteGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Directory site ID. - pub fn id(mut self, new_value: &str) -> DirectorySiteGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> DirectorySiteGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -47862,7 +47858,7 @@ impl<'a, C, NC, A> DirectorySiteGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DirectorySiteGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DirectorySiteGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -47883,7 +47879,7 @@ impl<'a, C, NC, A> DirectorySiteGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DirectorySiteGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DirectorySiteGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -47900,7 +47896,7 @@ impl<'a, C, NC, A> DirectorySiteGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DirectorySiteGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DirectorySiteGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -47944,10 +47940,10 @@ impl<'a, C, NC, A> DirectorySiteGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct SizeInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SizeInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Size, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -47955,9 +47951,9 @@ pub struct SizeInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SizeInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SizeInsertCall<'a, C, A> {} -impl<'a, C, NC, A> SizeInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SizeInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -48096,7 +48092,7 @@ impl<'a, C, NC, A> SizeInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Size) -> SizeInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Size) -> SizeInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -48106,7 +48102,7 @@ impl<'a, C, NC, A> SizeInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> SizeInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> SizeInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -48117,7 +48113,7 @@ impl<'a, C, NC, A> SizeInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SizeInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SizeInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -48138,7 +48134,7 @@ impl<'a, C, NC, A> SizeInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SizeInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SizeInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -48155,7 +48151,7 @@ impl<'a, C, NC, A> SizeInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SizeInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SizeInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -48197,10 +48193,10 @@ impl<'a, C, NC, A> SizeInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct SizeListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SizeListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _width: Option, _ids: Vec, @@ -48211,9 +48207,9 @@ pub struct SizeListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SizeListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SizeListCall<'a, C, A> {} -impl<'a, C, NC, A> SizeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SizeListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -48361,7 +48357,7 @@ impl<'a, C, NC, A> SizeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> SizeListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> SizeListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -48369,7 +48365,7 @@ impl<'a, C, NC, A> SizeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Select only sizes with this width. - pub fn width(mut self, new_value: i32) -> SizeListCall<'a, C, NC, A> { + pub fn width(mut self, new_value: i32) -> SizeListCall<'a, C, A> { self._width = Some(new_value); self } @@ -48378,7 +48374,7 @@ impl<'a, C, NC, A> SizeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Select only sizes with these IDs. - pub fn add_ids(mut self, new_value: &str) -> SizeListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> SizeListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -48386,7 +48382,7 @@ impl<'a, C, NC, A> SizeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Select only IAB standard sizes. - pub fn iab_standard(mut self, new_value: bool) -> SizeListCall<'a, C, NC, A> { + pub fn iab_standard(mut self, new_value: bool) -> SizeListCall<'a, C, A> { self._iab_standard = Some(new_value); self } @@ -48394,7 +48390,7 @@ impl<'a, C, NC, A> SizeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Select only sizes with this height. - pub fn height(mut self, new_value: i32) -> SizeListCall<'a, C, NC, A> { + pub fn height(mut self, new_value: i32) -> SizeListCall<'a, C, A> { self._height = Some(new_value); self } @@ -48405,7 +48401,7 @@ impl<'a, C, NC, A> SizeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SizeListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SizeListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -48426,7 +48422,7 @@ impl<'a, C, NC, A> SizeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SizeListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SizeListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -48443,7 +48439,7 @@ impl<'a, C, NC, A> SizeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SizeListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SizeListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -48481,10 +48477,10 @@ impl<'a, C, NC, A> SizeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct SizeGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SizeGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -48492,9 +48488,9 @@ pub struct SizeGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SizeGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SizeGetCall<'a, C, A> {} -impl<'a, C, NC, A> SizeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SizeGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -48627,7 +48623,7 @@ impl<'a, C, NC, A> SizeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> SizeGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> SizeGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -48637,7 +48633,7 @@ impl<'a, C, NC, A> SizeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// Size ID. - pub fn id(mut self, new_value: &str) -> SizeGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> SizeGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -48648,7 +48644,7 @@ impl<'a, C, NC, A> SizeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SizeGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SizeGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -48669,7 +48665,7 @@ impl<'a, C, NC, A> SizeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SizeGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SizeGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -48686,7 +48682,7 @@ impl<'a, C, NC, A> SizeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SizeGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SizeGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -48724,10 +48720,10 @@ impl<'a, C, NC, A> SizeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct AccountActiveAdSummaryGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountActiveAdSummaryGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _summary_account_id: String, _delegate: Option<&'a mut Delegate>, @@ -48735,9 +48731,9 @@ pub struct AccountActiveAdSummaryGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountActiveAdSummaryGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountActiveAdSummaryGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountActiveAdSummaryGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountActiveAdSummaryGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -48870,7 +48866,7 @@ impl<'a, C, NC, A> AccountActiveAdSummaryGetCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AccountActiveAdSummaryGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AccountActiveAdSummaryGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -48880,7 +48876,7 @@ impl<'a, C, NC, A> AccountActiveAdSummaryGetCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Account ID. - pub fn summary_account_id(mut self, new_value: &str) -> AccountActiveAdSummaryGetCall<'a, C, NC, A> { + pub fn summary_account_id(mut self, new_value: &str) -> AccountActiveAdSummaryGetCall<'a, C, A> { self._summary_account_id = new_value.to_string(); self } @@ -48891,7 +48887,7 @@ impl<'a, C, NC, A> AccountActiveAdSummaryGetCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountActiveAdSummaryGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountActiveAdSummaryGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -48912,7 +48908,7 @@ impl<'a, C, NC, A> AccountActiveAdSummaryGetCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountActiveAdSummaryGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountActiveAdSummaryGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -48929,7 +48925,7 @@ impl<'a, C, NC, A> AccountActiveAdSummaryGetCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountActiveAdSummaryGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountActiveAdSummaryGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -48973,10 +48969,10 @@ impl<'a, C, NC, A> AccountActiveAdSummaryGetCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct AccountUserProfileUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountUserProfileUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: AccountUserProfile, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -48984,9 +48980,9 @@ pub struct AccountUserProfileUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountUserProfileUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountUserProfileUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountUserProfileUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountUserProfileUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -49125,7 +49121,7 @@ impl<'a, C, NC, A> AccountUserProfileUpdateCall<'a, C, NC, A> where NC: hyper::n /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AccountUserProfile) -> AccountUserProfileUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AccountUserProfile) -> AccountUserProfileUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -49135,7 +49131,7 @@ impl<'a, C, NC, A> AccountUserProfileUpdateCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AccountUserProfileUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AccountUserProfileUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -49146,7 +49142,7 @@ impl<'a, C, NC, A> AccountUserProfileUpdateCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountUserProfileUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountUserProfileUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -49167,7 +49163,7 @@ impl<'a, C, NC, A> AccountUserProfileUpdateCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountUserProfileUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountUserProfileUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -49184,7 +49180,7 @@ impl<'a, C, NC, A> AccountUserProfileUpdateCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountUserProfileUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountUserProfileUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -49231,10 +49227,10 @@ impl<'a, C, NC, A> AccountUserProfileUpdateCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct AccountUserProfileListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountUserProfileListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _user_role_id: Option, _subaccount_id: Option, @@ -49250,9 +49246,9 @@ pub struct AccountUserProfileListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountUserProfileListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountUserProfileListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountUserProfileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountUserProfileListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -49415,7 +49411,7 @@ impl<'a, C, NC, A> AccountUserProfileListCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AccountUserProfileListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AccountUserProfileListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -49423,7 +49419,7 @@ impl<'a, C, NC, A> AccountUserProfileListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Select only user profiles with the specified user role ID. - pub fn user_role_id(mut self, new_value: &str) -> AccountUserProfileListCall<'a, C, NC, A> { + pub fn user_role_id(mut self, new_value: &str) -> AccountUserProfileListCall<'a, C, A> { self._user_role_id = Some(new_value.to_string()); self } @@ -49431,7 +49427,7 @@ impl<'a, C, NC, A> AccountUserProfileListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Select only user profiles with the specified subaccount ID. - pub fn subaccount_id(mut self, new_value: &str) -> AccountUserProfileListCall<'a, C, NC, A> { + pub fn subaccount_id(mut self, new_value: &str) -> AccountUserProfileListCall<'a, C, A> { self._subaccount_id = Some(new_value.to_string()); self } @@ -49439,7 +49435,7 @@ impl<'a, C, NC, A> AccountUserProfileListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Order of sorted results, default is ASCENDING. - pub fn sort_order(mut self, new_value: &str) -> AccountUserProfileListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> AccountUserProfileListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -49447,7 +49443,7 @@ impl<'a, C, NC, A> AccountUserProfileListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> AccountUserProfileListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> AccountUserProfileListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -49455,7 +49451,7 @@ impl<'a, C, NC, A> AccountUserProfileListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Allows searching for objects by name, ID or email. Wildcards (*) are allowed. For example, "user profile*2015" will return objects with names like "user profile June 2015", "user profile April 2015", or simply "user profile 2015". Most of the searches also add wildcards implicitly at the start and the end of the search string. For example, a search string of "user profile" will match objects with name "my user profile", "user profile 2015", or simply "user profile". - pub fn search_string(mut self, new_value: &str) -> AccountUserProfileListCall<'a, C, NC, A> { + pub fn search_string(mut self, new_value: &str) -> AccountUserProfileListCall<'a, C, A> { self._search_string = Some(new_value.to_string()); self } @@ -49463,7 +49459,7 @@ impl<'a, C, NC, A> AccountUserProfileListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Value of the nextPageToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> AccountUserProfileListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AccountUserProfileListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -49471,7 +49467,7 @@ impl<'a, C, NC, A> AccountUserProfileListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> AccountUserProfileListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AccountUserProfileListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -49480,7 +49476,7 @@ impl<'a, C, NC, A> AccountUserProfileListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Select only user profiles with these IDs. - pub fn add_ids(mut self, new_value: &str) -> AccountUserProfileListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> AccountUserProfileListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -49488,7 +49484,7 @@ impl<'a, C, NC, A> AccountUserProfileListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Select only active user profiles. - pub fn active(mut self, new_value: bool) -> AccountUserProfileListCall<'a, C, NC, A> { + pub fn active(mut self, new_value: bool) -> AccountUserProfileListCall<'a, C, A> { self._active = Some(new_value); self } @@ -49499,7 +49495,7 @@ impl<'a, C, NC, A> AccountUserProfileListCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountUserProfileListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountUserProfileListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -49520,7 +49516,7 @@ impl<'a, C, NC, A> AccountUserProfileListCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountUserProfileListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountUserProfileListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -49537,7 +49533,7 @@ impl<'a, C, NC, A> AccountUserProfileListCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountUserProfileListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountUserProfileListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -49581,10 +49577,10 @@ impl<'a, C, NC, A> AccountUserProfileListCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct AccountUserProfilePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountUserProfilePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: AccountUserProfile, _profile_id: String, _id: String, @@ -49593,9 +49589,9 @@ pub struct AccountUserProfilePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountUserProfilePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountUserProfilePatchCall<'a, C, A> {} -impl<'a, C, NC, A> AccountUserProfilePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountUserProfilePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -49735,7 +49731,7 @@ impl<'a, C, NC, A> AccountUserProfilePatchCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AccountUserProfile) -> AccountUserProfilePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AccountUserProfile) -> AccountUserProfilePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -49745,7 +49741,7 @@ impl<'a, C, NC, A> AccountUserProfilePatchCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AccountUserProfilePatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AccountUserProfilePatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -49755,7 +49751,7 @@ impl<'a, C, NC, A> AccountUserProfilePatchCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// User profile ID. - pub fn id(mut self, new_value: &str) -> AccountUserProfilePatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> AccountUserProfilePatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -49766,7 +49762,7 @@ impl<'a, C, NC, A> AccountUserProfilePatchCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountUserProfilePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountUserProfilePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -49787,7 +49783,7 @@ impl<'a, C, NC, A> AccountUserProfilePatchCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountUserProfilePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountUserProfilePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -49804,7 +49800,7 @@ impl<'a, C, NC, A> AccountUserProfilePatchCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountUserProfilePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountUserProfilePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -49842,10 +49838,10 @@ impl<'a, C, NC, A> AccountUserProfilePatchCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct AccountUserProfileGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountUserProfileGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -49853,9 +49849,9 @@ pub struct AccountUserProfileGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountUserProfileGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountUserProfileGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountUserProfileGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountUserProfileGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -49988,7 +49984,7 @@ impl<'a, C, NC, A> AccountUserProfileGetCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> AccountUserProfileGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> AccountUserProfileGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -49998,7 +49994,7 @@ impl<'a, C, NC, A> AccountUserProfileGetCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// User profile ID. - pub fn id(mut self, new_value: &str) -> AccountUserProfileGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> AccountUserProfileGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -50009,7 +50005,7 @@ impl<'a, C, NC, A> AccountUserProfileGetCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountUserProfileGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountUserProfileGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -50030,7 +50026,7 @@ impl<'a, C, NC, A> AccountUserProfileGetCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountUserProfileGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountUserProfileGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -50047,7 +50043,7 @@ impl<'a, C, NC, A> AccountUserProfileGetCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountUserProfileGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountUserProfileGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -50085,19 +50081,19 @@ impl<'a, C, NC, A> AccountUserProfileGetCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct CountryListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CountryListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CountryListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CountryListCall<'a, C, A> {} -impl<'a, C, NC, A> CountryListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CountryListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -50229,7 +50225,7 @@ impl<'a, C, NC, A> CountryListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CountryListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CountryListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -50240,7 +50236,7 @@ impl<'a, C, NC, A> CountryListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CountryListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CountryListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -50261,7 +50257,7 @@ impl<'a, C, NC, A> CountryListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CountryListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CountryListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -50278,7 +50274,7 @@ impl<'a, C, NC, A> CountryListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CountryListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CountryListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -50316,10 +50312,10 @@ impl<'a, C, NC, A> CountryListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct CountryGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CountryGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _dart_id: String, _delegate: Option<&'a mut Delegate>, @@ -50327,9 +50323,9 @@ pub struct CountryGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CountryGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CountryGetCall<'a, C, A> {} -impl<'a, C, NC, A> CountryGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CountryGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -50462,7 +50458,7 @@ impl<'a, C, NC, A> CountryGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CountryGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CountryGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -50472,7 +50468,7 @@ impl<'a, C, NC, A> CountryGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Country DART ID. - pub fn dart_id(mut self, new_value: &str) -> CountryGetCall<'a, C, NC, A> { + pub fn dart_id(mut self, new_value: &str) -> CountryGetCall<'a, C, A> { self._dart_id = new_value.to_string(); self } @@ -50483,7 +50479,7 @@ impl<'a, C, NC, A> CountryGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CountryGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CountryGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -50504,7 +50500,7 @@ impl<'a, C, NC, A> CountryGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CountryGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CountryGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -50521,7 +50517,7 @@ impl<'a, C, NC, A> CountryGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CountryGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CountryGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -50565,10 +50561,10 @@ impl<'a, C, NC, A> CountryGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct CreativeFieldValuePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeFieldValuePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: CreativeFieldValue, _profile_id: String, _creative_field_id: String, @@ -50578,9 +50574,9 @@ pub struct CreativeFieldValuePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeFieldValuePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeFieldValuePatchCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeFieldValuePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeFieldValuePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -50721,7 +50717,7 @@ impl<'a, C, NC, A> CreativeFieldValuePatchCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CreativeFieldValue) -> CreativeFieldValuePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CreativeFieldValue) -> CreativeFieldValuePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -50731,7 +50727,7 @@ impl<'a, C, NC, A> CreativeFieldValuePatchCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CreativeFieldValuePatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CreativeFieldValuePatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -50741,7 +50737,7 @@ impl<'a, C, NC, A> CreativeFieldValuePatchCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Creative field ID for this creative field value. - pub fn creative_field_id(mut self, new_value: &str) -> CreativeFieldValuePatchCall<'a, C, NC, A> { + pub fn creative_field_id(mut self, new_value: &str) -> CreativeFieldValuePatchCall<'a, C, A> { self._creative_field_id = new_value.to_string(); self } @@ -50751,7 +50747,7 @@ impl<'a, C, NC, A> CreativeFieldValuePatchCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Creative Field Value ID - pub fn id(mut self, new_value: &str) -> CreativeFieldValuePatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> CreativeFieldValuePatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -50762,7 +50758,7 @@ impl<'a, C, NC, A> CreativeFieldValuePatchCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldValuePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldValuePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -50783,7 +50779,7 @@ impl<'a, C, NC, A> CreativeFieldValuePatchCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeFieldValuePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeFieldValuePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -50800,7 +50796,7 @@ impl<'a, C, NC, A> CreativeFieldValuePatchCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeFieldValuePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeFieldValuePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -50838,10 +50834,10 @@ impl<'a, C, NC, A> CreativeFieldValuePatchCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct CreativeFieldValueDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeFieldValueDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _creative_field_id: String, _id: String, @@ -50850,9 +50846,9 @@ pub struct CreativeFieldValueDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeFieldValueDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeFieldValueDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeFieldValueDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeFieldValueDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -50975,7 +50971,7 @@ impl<'a, C, NC, A> CreativeFieldValueDeleteCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CreativeFieldValueDeleteCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CreativeFieldValueDeleteCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -50985,7 +50981,7 @@ impl<'a, C, NC, A> CreativeFieldValueDeleteCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Creative field ID for this creative field value. - pub fn creative_field_id(mut self, new_value: &str) -> CreativeFieldValueDeleteCall<'a, C, NC, A> { + pub fn creative_field_id(mut self, new_value: &str) -> CreativeFieldValueDeleteCall<'a, C, A> { self._creative_field_id = new_value.to_string(); self } @@ -50995,7 +50991,7 @@ impl<'a, C, NC, A> CreativeFieldValueDeleteCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Creative Field Value ID - pub fn id(mut self, new_value: &str) -> CreativeFieldValueDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> CreativeFieldValueDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -51006,7 +51002,7 @@ impl<'a, C, NC, A> CreativeFieldValueDeleteCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldValueDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldValueDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -51027,7 +51023,7 @@ impl<'a, C, NC, A> CreativeFieldValueDeleteCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeFieldValueDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeFieldValueDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -51044,7 +51040,7 @@ impl<'a, C, NC, A> CreativeFieldValueDeleteCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeFieldValueDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeFieldValueDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -51088,10 +51084,10 @@ impl<'a, C, NC, A> CreativeFieldValueDeleteCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct CreativeFieldValueInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeFieldValueInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: CreativeFieldValue, _profile_id: String, _creative_field_id: String, @@ -51100,9 +51096,9 @@ pub struct CreativeFieldValueInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeFieldValueInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeFieldValueInsertCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeFieldValueInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeFieldValueInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -51242,7 +51238,7 @@ impl<'a, C, NC, A> CreativeFieldValueInsertCall<'a, C, NC, A> where NC: hyper::n /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CreativeFieldValue) -> CreativeFieldValueInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CreativeFieldValue) -> CreativeFieldValueInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -51252,7 +51248,7 @@ impl<'a, C, NC, A> CreativeFieldValueInsertCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CreativeFieldValueInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CreativeFieldValueInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -51262,7 +51258,7 @@ impl<'a, C, NC, A> CreativeFieldValueInsertCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Creative field ID for this creative field value. - pub fn creative_field_id(mut self, new_value: &str) -> CreativeFieldValueInsertCall<'a, C, NC, A> { + pub fn creative_field_id(mut self, new_value: &str) -> CreativeFieldValueInsertCall<'a, C, A> { self._creative_field_id = new_value.to_string(); self } @@ -51273,7 +51269,7 @@ impl<'a, C, NC, A> CreativeFieldValueInsertCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldValueInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldValueInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -51294,7 +51290,7 @@ impl<'a, C, NC, A> CreativeFieldValueInsertCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeFieldValueInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeFieldValueInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -51311,7 +51307,7 @@ impl<'a, C, NC, A> CreativeFieldValueInsertCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeFieldValueInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeFieldValueInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -51355,10 +51351,10 @@ impl<'a, C, NC, A> CreativeFieldValueInsertCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct CreativeFieldValueUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeFieldValueUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: CreativeFieldValue, _profile_id: String, _creative_field_id: String, @@ -51367,9 +51363,9 @@ pub struct CreativeFieldValueUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeFieldValueUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeFieldValueUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeFieldValueUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeFieldValueUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -51509,7 +51505,7 @@ impl<'a, C, NC, A> CreativeFieldValueUpdateCall<'a, C, NC, A> where NC: hyper::n /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CreativeFieldValue) -> CreativeFieldValueUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CreativeFieldValue) -> CreativeFieldValueUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -51519,7 +51515,7 @@ impl<'a, C, NC, A> CreativeFieldValueUpdateCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CreativeFieldValueUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CreativeFieldValueUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -51529,7 +51525,7 @@ impl<'a, C, NC, A> CreativeFieldValueUpdateCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Creative field ID for this creative field value. - pub fn creative_field_id(mut self, new_value: &str) -> CreativeFieldValueUpdateCall<'a, C, NC, A> { + pub fn creative_field_id(mut self, new_value: &str) -> CreativeFieldValueUpdateCall<'a, C, A> { self._creative_field_id = new_value.to_string(); self } @@ -51540,7 +51536,7 @@ impl<'a, C, NC, A> CreativeFieldValueUpdateCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldValueUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldValueUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -51561,7 +51557,7 @@ impl<'a, C, NC, A> CreativeFieldValueUpdateCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeFieldValueUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeFieldValueUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -51578,7 +51574,7 @@ impl<'a, C, NC, A> CreativeFieldValueUpdateCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeFieldValueUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeFieldValueUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -51616,10 +51612,10 @@ impl<'a, C, NC, A> CreativeFieldValueUpdateCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct CreativeFieldValueGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeFieldValueGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _creative_field_id: String, _id: String, @@ -51628,9 +51624,9 @@ pub struct CreativeFieldValueGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeFieldValueGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeFieldValueGetCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeFieldValueGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeFieldValueGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -51764,7 +51760,7 @@ impl<'a, C, NC, A> CreativeFieldValueGetCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CreativeFieldValueGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CreativeFieldValueGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -51774,7 +51770,7 @@ impl<'a, C, NC, A> CreativeFieldValueGetCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Creative field ID for this creative field value. - pub fn creative_field_id(mut self, new_value: &str) -> CreativeFieldValueGetCall<'a, C, NC, A> { + pub fn creative_field_id(mut self, new_value: &str) -> CreativeFieldValueGetCall<'a, C, A> { self._creative_field_id = new_value.to_string(); self } @@ -51784,7 +51780,7 @@ impl<'a, C, NC, A> CreativeFieldValueGetCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Creative Field Value ID - pub fn id(mut self, new_value: &str) -> CreativeFieldValueGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> CreativeFieldValueGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -51795,7 +51791,7 @@ impl<'a, C, NC, A> CreativeFieldValueGetCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldValueGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldValueGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -51816,7 +51812,7 @@ impl<'a, C, NC, A> CreativeFieldValueGetCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeFieldValueGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeFieldValueGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -51833,7 +51829,7 @@ impl<'a, C, NC, A> CreativeFieldValueGetCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeFieldValueGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeFieldValueGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -51877,10 +51873,10 @@ impl<'a, C, NC, A> CreativeFieldValueGetCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct CreativeFieldValueListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CreativeFieldValueListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _creative_field_id: String, _sort_order: Option, @@ -51894,9 +51890,9 @@ pub struct CreativeFieldValueListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CreativeFieldValueListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CreativeFieldValueListCall<'a, C, A> {} -impl<'a, C, NC, A> CreativeFieldValueListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CreativeFieldValueListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -52051,7 +52047,7 @@ impl<'a, C, NC, A> CreativeFieldValueListCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> CreativeFieldValueListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> CreativeFieldValueListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -52061,7 +52057,7 @@ impl<'a, C, NC, A> CreativeFieldValueListCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Creative field ID for this creative field value. - pub fn creative_field_id(mut self, new_value: &str) -> CreativeFieldValueListCall<'a, C, NC, A> { + pub fn creative_field_id(mut self, new_value: &str) -> CreativeFieldValueListCall<'a, C, A> { self._creative_field_id = new_value.to_string(); self } @@ -52069,7 +52065,7 @@ impl<'a, C, NC, A> CreativeFieldValueListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Order of sorted results, default is ASCENDING. - pub fn sort_order(mut self, new_value: &str) -> CreativeFieldValueListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> CreativeFieldValueListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -52077,7 +52073,7 @@ impl<'a, C, NC, A> CreativeFieldValueListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> CreativeFieldValueListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> CreativeFieldValueListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -52085,7 +52081,7 @@ impl<'a, C, NC, A> CreativeFieldValueListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Allows searching for creative field values by their values. Wildcards (e.g. *) are not allowed. - pub fn search_string(mut self, new_value: &str) -> CreativeFieldValueListCall<'a, C, NC, A> { + pub fn search_string(mut self, new_value: &str) -> CreativeFieldValueListCall<'a, C, A> { self._search_string = Some(new_value.to_string()); self } @@ -52093,7 +52089,7 @@ impl<'a, C, NC, A> CreativeFieldValueListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Value of the nextPageToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> CreativeFieldValueListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> CreativeFieldValueListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -52101,7 +52097,7 @@ impl<'a, C, NC, A> CreativeFieldValueListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> CreativeFieldValueListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> CreativeFieldValueListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -52110,7 +52106,7 @@ impl<'a, C, NC, A> CreativeFieldValueListCall<'a, C, NC, A> where NC: hyper::net /// /// /// Select only creative field values with these IDs. - pub fn add_ids(mut self, new_value: &str) -> CreativeFieldValueListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> CreativeFieldValueListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -52121,7 +52117,7 @@ impl<'a, C, NC, A> CreativeFieldValueListCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldValueListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CreativeFieldValueListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -52142,7 +52138,7 @@ impl<'a, C, NC, A> CreativeFieldValueListCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CreativeFieldValueListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CreativeFieldValueListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -52159,7 +52155,7 @@ impl<'a, C, NC, A> CreativeFieldValueListCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CreativeFieldValueListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CreativeFieldValueListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -52203,10 +52199,10 @@ impl<'a, C, NC, A> CreativeFieldValueListCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct ReportUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Report, _profile_id: String, _report_id: String, @@ -52215,9 +52211,9 @@ pub struct ReportUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReportUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReportUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ReportUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReportUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -52357,7 +52353,7 @@ impl<'a, C, NC, A> ReportUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Report) -> ReportUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Report) -> ReportUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -52367,7 +52363,7 @@ impl<'a, C, NC, A> ReportUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The DFA user profile ID. - pub fn profile_id(mut self, new_value: &str) -> ReportUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ReportUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -52377,7 +52373,7 @@ impl<'a, C, NC, A> ReportUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the report. - pub fn report_id(mut self, new_value: &str) -> ReportUpdateCall<'a, C, NC, A> { + pub fn report_id(mut self, new_value: &str) -> ReportUpdateCall<'a, C, A> { self._report_id = new_value.to_string(); self } @@ -52388,7 +52384,7 @@ impl<'a, C, NC, A> ReportUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -52409,7 +52405,7 @@ impl<'a, C, NC, A> ReportUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReportUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReportUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -52426,7 +52422,7 @@ impl<'a, C, NC, A> ReportUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReportUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReportUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -52465,10 +52461,10 @@ impl<'a, C, NC, A> ReportUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct ReportRunCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportRunCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _report_id: String, _synchronous: Option, @@ -52477,9 +52473,9 @@ pub struct ReportRunCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReportRunCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReportRunCall<'a, C, A> {} -impl<'a, C, NC, A> ReportRunCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReportRunCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -52615,7 +52611,7 @@ impl<'a, C, NC, A> ReportRunCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The DFA profile ID. - pub fn profile_id(mut self, new_value: &str) -> ReportRunCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ReportRunCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -52625,7 +52621,7 @@ impl<'a, C, NC, A> ReportRunCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the report. - pub fn report_id(mut self, new_value: &str) -> ReportRunCall<'a, C, NC, A> { + pub fn report_id(mut self, new_value: &str) -> ReportRunCall<'a, C, A> { self._report_id = new_value.to_string(); self } @@ -52633,7 +52629,7 @@ impl<'a, C, NC, A> ReportRunCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// If set and true, tries to run the report synchronously. - pub fn synchronous(mut self, new_value: bool) -> ReportRunCall<'a, C, NC, A> { + pub fn synchronous(mut self, new_value: bool) -> ReportRunCall<'a, C, A> { self._synchronous = Some(new_value); self } @@ -52644,7 +52640,7 @@ impl<'a, C, NC, A> ReportRunCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportRunCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportRunCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -52665,7 +52661,7 @@ impl<'a, C, NC, A> ReportRunCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReportRunCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReportRunCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -52682,7 +52678,7 @@ impl<'a, C, NC, A> ReportRunCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReportRunCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReportRunCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -52726,10 +52722,10 @@ impl<'a, C, NC, A> ReportRunCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct ReportPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Report, _profile_id: String, _report_id: String, @@ -52738,9 +52734,9 @@ pub struct ReportPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReportPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReportPatchCall<'a, C, A> {} -impl<'a, C, NC, A> ReportPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReportPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -52880,7 +52876,7 @@ impl<'a, C, NC, A> ReportPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Report) -> ReportPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Report) -> ReportPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -52890,7 +52886,7 @@ impl<'a, C, NC, A> ReportPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The DFA user profile ID. - pub fn profile_id(mut self, new_value: &str) -> ReportPatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ReportPatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -52900,7 +52896,7 @@ impl<'a, C, NC, A> ReportPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the report. - pub fn report_id(mut self, new_value: &str) -> ReportPatchCall<'a, C, NC, A> { + pub fn report_id(mut self, new_value: &str) -> ReportPatchCall<'a, C, A> { self._report_id = new_value.to_string(); self } @@ -52911,7 +52907,7 @@ impl<'a, C, NC, A> ReportPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -52932,7 +52928,7 @@ impl<'a, C, NC, A> ReportPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReportPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReportPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -52949,7 +52945,7 @@ impl<'a, C, NC, A> ReportPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReportPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReportPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -52991,10 +52987,10 @@ impl<'a, C, NC, A> ReportPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct ReportFileListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportFileListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _report_id: String, _sort_order: Option, @@ -53006,9 +53002,9 @@ pub struct ReportFileListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReportFileListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReportFileListCall<'a, C, A> {} -impl<'a, C, NC, A> ReportFileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReportFileListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -53153,7 +53149,7 @@ impl<'a, C, NC, A> ReportFileListCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The DFA profile ID. - pub fn profile_id(mut self, new_value: &str) -> ReportFileListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ReportFileListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -53163,7 +53159,7 @@ impl<'a, C, NC, A> ReportFileListCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the parent report. - pub fn report_id(mut self, new_value: &str) -> ReportFileListCall<'a, C, NC, A> { + pub fn report_id(mut self, new_value: &str) -> ReportFileListCall<'a, C, A> { self._report_id = new_value.to_string(); self } @@ -53171,7 +53167,7 @@ impl<'a, C, NC, A> ReportFileListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Order of sorted results, default is 'DESCENDING'. - pub fn sort_order(mut self, new_value: &str) -> ReportFileListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> ReportFileListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -53179,7 +53175,7 @@ impl<'a, C, NC, A> ReportFileListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> ReportFileListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> ReportFileListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -53187,7 +53183,7 @@ impl<'a, C, NC, A> ReportFileListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The value of the nextToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> ReportFileListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ReportFileListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -53195,7 +53191,7 @@ impl<'a, C, NC, A> ReportFileListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> ReportFileListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ReportFileListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -53206,7 +53202,7 @@ impl<'a, C, NC, A> ReportFileListCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportFileListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportFileListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -53227,7 +53223,7 @@ impl<'a, C, NC, A> ReportFileListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReportFileListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReportFileListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -53244,7 +53240,7 @@ impl<'a, C, NC, A> ReportFileListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReportFileListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReportFileListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -53288,10 +53284,10 @@ impl<'a, C, NC, A> ReportFileListCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct ReportInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Report, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -53299,9 +53295,9 @@ pub struct ReportInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReportInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReportInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ReportInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReportInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -53440,7 +53436,7 @@ impl<'a, C, NC, A> ReportInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Report) -> ReportInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Report) -> ReportInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -53450,7 +53446,7 @@ impl<'a, C, NC, A> ReportInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The DFA user profile ID. - pub fn profile_id(mut self, new_value: &str) -> ReportInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ReportInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -53461,7 +53457,7 @@ impl<'a, C, NC, A> ReportInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -53482,7 +53478,7 @@ impl<'a, C, NC, A> ReportInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReportInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReportInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -53499,7 +53495,7 @@ impl<'a, C, NC, A> ReportInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReportInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReportInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -53543,10 +53539,10 @@ impl<'a, C, NC, A> ReportInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct ReportCompatibleFieldQueryCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportCompatibleFieldQueryCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Report, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -53554,9 +53550,9 @@ pub struct ReportCompatibleFieldQueryCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReportCompatibleFieldQueryCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReportCompatibleFieldQueryCall<'a, C, A> {} -impl<'a, C, NC, A> ReportCompatibleFieldQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReportCompatibleFieldQueryCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -53695,7 +53691,7 @@ impl<'a, C, NC, A> ReportCompatibleFieldQueryCall<'a, C, NC, A> where NC: hyper: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Report) -> ReportCompatibleFieldQueryCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Report) -> ReportCompatibleFieldQueryCall<'a, C, A> { self._request = new_value.clone(); self } @@ -53705,7 +53701,7 @@ impl<'a, C, NC, A> ReportCompatibleFieldQueryCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The DFA user profile ID. - pub fn profile_id(mut self, new_value: &str) -> ReportCompatibleFieldQueryCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ReportCompatibleFieldQueryCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -53716,7 +53712,7 @@ impl<'a, C, NC, A> ReportCompatibleFieldQueryCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportCompatibleFieldQueryCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportCompatibleFieldQueryCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -53737,7 +53733,7 @@ impl<'a, C, NC, A> ReportCompatibleFieldQueryCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReportCompatibleFieldQueryCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReportCompatibleFieldQueryCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -53754,7 +53750,7 @@ impl<'a, C, NC, A> ReportCompatibleFieldQueryCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReportCompatibleFieldQueryCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReportCompatibleFieldQueryCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -53792,10 +53788,10 @@ impl<'a, C, NC, A> ReportCompatibleFieldQueryCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct ReportGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _report_id: String, _delegate: Option<&'a mut Delegate>, @@ -53803,9 +53799,9 @@ pub struct ReportGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReportGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReportGetCall<'a, C, A> {} -impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReportGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -53938,7 +53934,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The DFA user profile ID. - pub fn profile_id(mut self, new_value: &str) -> ReportGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ReportGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -53948,7 +53944,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the report. - pub fn report_id(mut self, new_value: &str) -> ReportGetCall<'a, C, NC, A> { + pub fn report_id(mut self, new_value: &str) -> ReportGetCall<'a, C, A> { self._report_id = new_value.to_string(); self } @@ -53959,7 +53955,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -53980,7 +53976,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReportGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReportGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -53997,7 +53993,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReportGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReportGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -54040,10 +54036,10 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct ReportFileGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportFileGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _report_id: String, _file_id: String, @@ -54052,9 +54048,9 @@ pub struct ReportFileGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReportFileGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReportFileGetCall<'a, C, A> {} -impl<'a, C, NC, A> ReportFileGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReportFileGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -54204,7 +54200,7 @@ impl<'a, C, NC, A> ReportFileGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The DFA profile ID. - pub fn profile_id(mut self, new_value: &str) -> ReportFileGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ReportFileGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -54214,7 +54210,7 @@ impl<'a, C, NC, A> ReportFileGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the report. - pub fn report_id(mut self, new_value: &str) -> ReportFileGetCall<'a, C, NC, A> { + pub fn report_id(mut self, new_value: &str) -> ReportFileGetCall<'a, C, A> { self._report_id = new_value.to_string(); self } @@ -54224,7 +54220,7 @@ impl<'a, C, NC, A> ReportFileGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the report file. - pub fn file_id(mut self, new_value: &str) -> ReportFileGetCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> ReportFileGetCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -54235,7 +54231,7 @@ impl<'a, C, NC, A> ReportFileGetCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportFileGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportFileGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -54256,7 +54252,7 @@ impl<'a, C, NC, A> ReportFileGetCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReportFileGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReportFileGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -54273,7 +54269,7 @@ impl<'a, C, NC, A> ReportFileGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReportFileGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReportFileGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -54311,10 +54307,10 @@ impl<'a, C, NC, A> ReportFileGetCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct ReportDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _report_id: String, _delegate: Option<&'a mut Delegate>, @@ -54322,9 +54318,9 @@ pub struct ReportDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReportDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReportDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ReportDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReportDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -54446,7 +54442,7 @@ impl<'a, C, NC, A> ReportDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The DFA user profile ID. - pub fn profile_id(mut self, new_value: &str) -> ReportDeleteCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ReportDeleteCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -54456,7 +54452,7 @@ impl<'a, C, NC, A> ReportDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the report. - pub fn report_id(mut self, new_value: &str) -> ReportDeleteCall<'a, C, NC, A> { + pub fn report_id(mut self, new_value: &str) -> ReportDeleteCall<'a, C, A> { self._report_id = new_value.to_string(); self } @@ -54467,7 +54463,7 @@ impl<'a, C, NC, A> ReportDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -54488,7 +54484,7 @@ impl<'a, C, NC, A> ReportDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReportDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReportDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -54505,7 +54501,7 @@ impl<'a, C, NC, A> ReportDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReportDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReportDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -54548,10 +54544,10 @@ impl<'a, C, NC, A> ReportDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct ReportListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _sort_order: Option, _sort_field: Option, @@ -54563,9 +54559,9 @@ pub struct ReportListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReportListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReportListCall<'a, C, A> {} -impl<'a, C, NC, A> ReportListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReportListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -54712,7 +54708,7 @@ impl<'a, C, NC, A> ReportListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The DFA user profile ID. - pub fn profile_id(mut self, new_value: &str) -> ReportListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> ReportListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -54720,7 +54716,7 @@ impl<'a, C, NC, A> ReportListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Order of sorted results, default is 'DESCENDING'. - pub fn sort_order(mut self, new_value: &str) -> ReportListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> ReportListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -54728,7 +54724,7 @@ impl<'a, C, NC, A> ReportListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> ReportListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> ReportListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -54736,7 +54732,7 @@ impl<'a, C, NC, A> ReportListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The scope that defines which results are returned, default is 'MINE'. - pub fn scope(mut self, new_value: &str) -> ReportListCall<'a, C, NC, A> { + pub fn scope(mut self, new_value: &str) -> ReportListCall<'a, C, A> { self._scope = Some(new_value.to_string()); self } @@ -54744,7 +54740,7 @@ impl<'a, C, NC, A> ReportListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The value of the nextToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> ReportListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ReportListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -54752,7 +54748,7 @@ impl<'a, C, NC, A> ReportListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> ReportListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ReportListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -54763,7 +54759,7 @@ impl<'a, C, NC, A> ReportListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -54784,7 +54780,7 @@ impl<'a, C, NC, A> ReportListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReportListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReportListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -54801,7 +54797,7 @@ impl<'a, C, NC, A> ReportListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReportListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReportListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -54839,19 +54835,19 @@ impl<'a, C, NC, A> ReportListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct BrowserListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BrowserListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BrowserListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BrowserListCall<'a, C, A> {} -impl<'a, C, NC, A> BrowserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BrowserListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -54983,7 +54979,7 @@ impl<'a, C, NC, A> BrowserListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> BrowserListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> BrowserListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -54994,7 +54990,7 @@ impl<'a, C, NC, A> BrowserListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BrowserListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BrowserListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -55015,7 +55011,7 @@ impl<'a, C, NC, A> BrowserListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BrowserListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BrowserListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -55032,7 +55028,7 @@ impl<'a, C, NC, A> BrowserListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BrowserListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BrowserListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -55076,10 +55072,10 @@ impl<'a, C, NC, A> BrowserListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct PlacementPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlacementPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Placement, _profile_id: String, _id: String, @@ -55088,9 +55084,9 @@ pub struct PlacementPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlacementPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlacementPatchCall<'a, C, A> {} -impl<'a, C, NC, A> PlacementPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlacementPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -55230,7 +55226,7 @@ impl<'a, C, NC, A> PlacementPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Placement) -> PlacementPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Placement) -> PlacementPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -55240,7 +55236,7 @@ impl<'a, C, NC, A> PlacementPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> PlacementPatchCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> PlacementPatchCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -55250,7 +55246,7 @@ impl<'a, C, NC, A> PlacementPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Placement ID. - pub fn id(mut self, new_value: &str) -> PlacementPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> PlacementPatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -55261,7 +55257,7 @@ impl<'a, C, NC, A> PlacementPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -55282,7 +55278,7 @@ impl<'a, C, NC, A> PlacementPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlacementPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlacementPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -55299,7 +55295,7 @@ impl<'a, C, NC, A> PlacementPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlacementPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlacementPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -55355,10 +55351,10 @@ impl<'a, C, NC, A> PlacementPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct PlacementListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlacementListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _sort_order: Option, _sort_field: Option, @@ -55383,9 +55379,9 @@ pub struct PlacementListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlacementListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlacementListCall<'a, C, A> {} -impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlacementListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -55615,7 +55611,7 @@ impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> PlacementListCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> PlacementListCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -55623,7 +55619,7 @@ impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Order of sorted results, default is ASCENDING. - pub fn sort_order(mut self, new_value: &str) -> PlacementListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> PlacementListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -55631,7 +55627,7 @@ impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Field by which to sort the list. - pub fn sort_field(mut self, new_value: &str) -> PlacementListCall<'a, C, NC, A> { + pub fn sort_field(mut self, new_value: &str) -> PlacementListCall<'a, C, A> { self._sort_field = Some(new_value.to_string()); self } @@ -55640,7 +55636,7 @@ impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Select only placements that are associated with these sizes. - pub fn add_size_ids(mut self, new_value: &str) -> PlacementListCall<'a, C, NC, A> { + pub fn add_size_ids(mut self, new_value: &str) -> PlacementListCall<'a, C, A> { self._size_ids.push(new_value.to_string()); self } @@ -55649,7 +55645,7 @@ impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Select only placements that are associated with these sites. - pub fn add_site_ids(mut self, new_value: &str) -> PlacementListCall<'a, C, NC, A> { + pub fn add_site_ids(mut self, new_value: &str) -> PlacementListCall<'a, C, A> { self._site_ids.push(new_value.to_string()); self } @@ -55657,7 +55653,7 @@ impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Allows searching for placements by name or ID. Wildcards (*) are allowed. For example, "placement*2015" will return placements with names like "placement June 2015", "placement May 2015", or simply "placements 2015". Most of the searches also add wildcards implicitly at the start and the end of the search string. For example, a search string of "placement" will match placements with name "my placement", "placement 2015", or simply "placement". - pub fn search_string(mut self, new_value: &str) -> PlacementListCall<'a, C, NC, A> { + pub fn search_string(mut self, new_value: &str) -> PlacementListCall<'a, C, A> { self._search_string = Some(new_value.to_string()); self } @@ -55666,7 +55662,7 @@ impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Select only placements with these pricing types. - pub fn add_pricing_types(mut self, new_value: &str) -> PlacementListCall<'a, C, NC, A> { + pub fn add_pricing_types(mut self, new_value: &str) -> PlacementListCall<'a, C, A> { self._pricing_types.push(new_value.to_string()); self } @@ -55675,7 +55671,7 @@ impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Select only placements that are associated with these placement strategies. - pub fn add_placement_strategy_ids(mut self, new_value: &str) -> PlacementListCall<'a, C, NC, A> { + pub fn add_placement_strategy_ids(mut self, new_value: &str) -> PlacementListCall<'a, C, A> { self._placement_strategy_ids.push(new_value.to_string()); self } @@ -55683,7 +55679,7 @@ impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Select only placements with this payment source. - pub fn payment_source(mut self, new_value: &str) -> PlacementListCall<'a, C, NC, A> { + pub fn payment_source(mut self, new_value: &str) -> PlacementListCall<'a, C, A> { self._payment_source = Some(new_value.to_string()); self } @@ -55691,7 +55687,7 @@ impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Value of the nextPageToken from the previous result page. - pub fn page_token(mut self, new_value: &str) -> PlacementListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> PlacementListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -55699,7 +55695,7 @@ impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: i32) -> PlacementListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> PlacementListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -55708,7 +55704,7 @@ impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Select only placements with these IDs. - pub fn add_ids(mut self, new_value: &str) -> PlacementListCall<'a, C, NC, A> { + pub fn add_ids(mut self, new_value: &str) -> PlacementListCall<'a, C, A> { self._ids.push(new_value.to_string()); self } @@ -55717,7 +55713,7 @@ impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Select only placements that belong to these placement groups. - pub fn add_group_ids(mut self, new_value: &str) -> PlacementListCall<'a, C, NC, A> { + pub fn add_group_ids(mut self, new_value: &str) -> PlacementListCall<'a, C, A> { self._group_ids.push(new_value.to_string()); self } @@ -55726,7 +55722,7 @@ impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Select only placements that are associated with these directory sites. - pub fn add_directory_site_ids(mut self, new_value: &str) -> PlacementListCall<'a, C, NC, A> { + pub fn add_directory_site_ids(mut self, new_value: &str) -> PlacementListCall<'a, C, A> { self._directory_site_ids.push(new_value.to_string()); self } @@ -55735,7 +55731,7 @@ impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Select only placements that are associated with these content categories. - pub fn add_content_category_ids(mut self, new_value: &str) -> PlacementListCall<'a, C, NC, A> { + pub fn add_content_category_ids(mut self, new_value: &str) -> PlacementListCall<'a, C, A> { self._content_category_ids.push(new_value.to_string()); self } @@ -55744,7 +55740,7 @@ impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Select only placements that are associated with these compatibilities. WEB and WEB_INTERSTITIAL refer to rendering either on desktop or on mobile devices for regular or interstitial ads respectively. APP and APP_INTERSTITIAL are for rendering in mobile apps.IN_STREAM_VIDEO refers to rendering in in-stream video ads developed with the VAST standard. - pub fn add_compatibilities(mut self, new_value: &str) -> PlacementListCall<'a, C, NC, A> { + pub fn add_compatibilities(mut self, new_value: &str) -> PlacementListCall<'a, C, A> { self._compatibilities.push(new_value.to_string()); self } @@ -55753,7 +55749,7 @@ impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Select only placements that belong to these campaigns. - pub fn add_campaign_ids(mut self, new_value: &str) -> PlacementListCall<'a, C, NC, A> { + pub fn add_campaign_ids(mut self, new_value: &str) -> PlacementListCall<'a, C, A> { self._campaign_ids.push(new_value.to_string()); self } @@ -55761,7 +55757,7 @@ impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Select only archived placements. Don't set this field to select both archived and non-archived placements. - pub fn archived(mut self, new_value: bool) -> PlacementListCall<'a, C, NC, A> { + pub fn archived(mut self, new_value: bool) -> PlacementListCall<'a, C, A> { self._archived = Some(new_value); self } @@ -55770,7 +55766,7 @@ impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Select only placements that belong to these advertisers. - pub fn add_advertiser_ids(mut self, new_value: &str) -> PlacementListCall<'a, C, NC, A> { + pub fn add_advertiser_ids(mut self, new_value: &str) -> PlacementListCall<'a, C, A> { self._advertiser_ids.push(new_value.to_string()); self } @@ -55781,7 +55777,7 @@ impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -55802,7 +55798,7 @@ impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlacementListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlacementListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -55819,7 +55815,7 @@ impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlacementListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlacementListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -55857,10 +55853,10 @@ impl<'a, C, NC, A> PlacementListCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct PlacementGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlacementGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -55868,9 +55864,9 @@ pub struct PlacementGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlacementGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlacementGetCall<'a, C, A> {} -impl<'a, C, NC, A> PlacementGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlacementGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -56003,7 +55999,7 @@ impl<'a, C, NC, A> PlacementGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> PlacementGetCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> PlacementGetCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -56013,7 +56009,7 @@ impl<'a, C, NC, A> PlacementGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Placement ID. - pub fn id(mut self, new_value: &str) -> PlacementGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> PlacementGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -56024,7 +56020,7 @@ impl<'a, C, NC, A> PlacementGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -56045,7 +56041,7 @@ impl<'a, C, NC, A> PlacementGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlacementGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlacementGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -56062,7 +56058,7 @@ impl<'a, C, NC, A> PlacementGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlacementGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlacementGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -56106,10 +56102,10 @@ impl<'a, C, NC, A> PlacementGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct PlacementInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlacementInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Placement, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -56117,9 +56113,9 @@ pub struct PlacementInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlacementInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlacementInsertCall<'a, C, A> {} -impl<'a, C, NC, A> PlacementInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlacementInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -56258,7 +56254,7 @@ impl<'a, C, NC, A> PlacementInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Placement) -> PlacementInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Placement) -> PlacementInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -56268,7 +56264,7 @@ impl<'a, C, NC, A> PlacementInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> PlacementInsertCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> PlacementInsertCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -56279,7 +56275,7 @@ impl<'a, C, NC, A> PlacementInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -56300,7 +56296,7 @@ impl<'a, C, NC, A> PlacementInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlacementInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlacementInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -56317,7 +56313,7 @@ impl<'a, C, NC, A> PlacementInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlacementInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlacementInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -56361,10 +56357,10 @@ impl<'a, C, NC, A> PlacementInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct PlacementUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlacementUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _request: Placement, _profile_id: String, _delegate: Option<&'a mut Delegate>, @@ -56372,9 +56368,9 @@ pub struct PlacementUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlacementUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlacementUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> PlacementUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlacementUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -56513,7 +56509,7 @@ impl<'a, C, NC, A> PlacementUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Placement) -> PlacementUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Placement) -> PlacementUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -56523,7 +56519,7 @@ impl<'a, C, NC, A> PlacementUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> PlacementUpdateCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> PlacementUpdateCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -56534,7 +56530,7 @@ impl<'a, C, NC, A> PlacementUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -56555,7 +56551,7 @@ impl<'a, C, NC, A> PlacementUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlacementUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlacementUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -56572,7 +56568,7 @@ impl<'a, C, NC, A> PlacementUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlacementUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlacementUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -56613,10 +56609,10 @@ impl<'a, C, NC, A> PlacementUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct PlacementGeneratetagCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlacementGeneratetagCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dfareporting, + hub: &'a Dfareporting, _profile_id: String, _tag_formats: Vec, _placement_ids: Vec, @@ -56626,9 +56622,9 @@ pub struct PlacementGeneratetagCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlacementGeneratetagCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlacementGeneratetagCall<'a, C, A> {} -impl<'a, C, NC, A> PlacementGeneratetagCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlacementGeneratetagCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -56777,7 +56773,7 @@ impl<'a, C, NC, A> PlacementGeneratetagCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// User profile ID associated with this request. - pub fn profile_id(mut self, new_value: &str) -> PlacementGeneratetagCall<'a, C, NC, A> { + pub fn profile_id(mut self, new_value: &str) -> PlacementGeneratetagCall<'a, C, A> { self._profile_id = new_value.to_string(); self } @@ -56786,7 +56782,7 @@ impl<'a, C, NC, A> PlacementGeneratetagCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// Tag formats to generate for these placements. - pub fn add_tag_formats(mut self, new_value: &str) -> PlacementGeneratetagCall<'a, C, NC, A> { + pub fn add_tag_formats(mut self, new_value: &str) -> PlacementGeneratetagCall<'a, C, A> { self._tag_formats.push(new_value.to_string()); self } @@ -56795,7 +56791,7 @@ impl<'a, C, NC, A> PlacementGeneratetagCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// Generate tags for these placements. - pub fn add_placement_ids(mut self, new_value: &str) -> PlacementGeneratetagCall<'a, C, NC, A> { + pub fn add_placement_ids(mut self, new_value: &str) -> PlacementGeneratetagCall<'a, C, A> { self._placement_ids.push(new_value.to_string()); self } @@ -56803,7 +56799,7 @@ impl<'a, C, NC, A> PlacementGeneratetagCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// Generate placements belonging to this campaign. This is a required field. - pub fn campaign_id(mut self, new_value: &str) -> PlacementGeneratetagCall<'a, C, NC, A> { + pub fn campaign_id(mut self, new_value: &str) -> PlacementGeneratetagCall<'a, C, A> { self._campaign_id = Some(new_value.to_string()); self } @@ -56814,7 +56810,7 @@ impl<'a, C, NC, A> PlacementGeneratetagCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementGeneratetagCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlacementGeneratetagCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -56835,7 +56831,7 @@ impl<'a, C, NC, A> PlacementGeneratetagCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlacementGeneratetagCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlacementGeneratetagCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -56852,7 +56848,7 @@ impl<'a, C, NC, A> PlacementGeneratetagCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlacementGeneratetagCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlacementGeneratetagCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/discovery1/Cargo.toml b/gen/discovery1/Cargo.toml index d7f53049212..12484ccfa81 100644 --- a/gen/discovery1/Cargo.toml +++ b/gen/discovery1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-discovery1" -version = "0.1.4+00000000" +version = "0.1.5+00000000" authors = ["Sebastian Thiel "] description = "A complete library to interact with discovery (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/discovery1" homepage = "https://developers.google.com/discovery/" -documentation = "http://byron.github.io/google-apis-rs/google-discovery1" +documentation = "http://byron.github.io/google-apis-rs/google_discovery1" license = "MIT" keywords = ["discovery", "google", "protocol", "web", "api"] diff --git a/gen/discovery1/README.md b/gen/discovery1/README.md index a2b752e2875..8c726132ff8 100644 --- a/gen/discovery1/README.md +++ b/gen/discovery1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-discovery1` library allows access to all features of the *Google discovery* service. -This documentation was generated from *discovery* crate version *0.1.4+00000000*, where *00000000* is the exact revision of the *discovery:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *discovery* crate version *0.1.5+00000000*, where *00000000* is the exact revision of the *discovery:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *discovery* *v1* API can be found at the [official documentation site](https://developers.google.com/discovery/). diff --git a/gen/discovery1/src/cmn.rs b/gen/discovery1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/discovery1/src/cmn.rs +++ b/gen/discovery1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/discovery1/src/lib.rs b/gen/discovery1/src/lib.rs index fa20a48a391..3bc0fb8c393 100644 --- a/gen/discovery1/src/lib.rs +++ b/gen/discovery1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *discovery* crate version *0.1.4+00000000*, where *00000000* is the exact revision of the *discovery:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *discovery* crate version *0.1.5+00000000*, where *00000000* is the exact revision of the *discovery:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *discovery* *v1* API can be found at the //! [official documentation site](https://developers.google.com/discovery/). @@ -188,7 +188,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -257,34 +256,31 @@ pub use cmn::{MultiPartReader, ToParts, MethodInfo, Result, Error, CallBuilder, /// } /// # } /// ``` -pub struct Discovery { +pub struct Discovery { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Discovery {} +impl<'a, C, A> Hub for Discovery {} -impl<'a, C, NC, A> Discovery - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Discovery + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Discovery { + pub fn new(client: C, authenticator: A) -> Discovery { Discovery { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn apis(&'a self) -> ApiMethods<'a, C, NC, A> { + pub fn apis(&'a self) -> ApiMethods<'a, C, A> { ApiMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -818,15 +814,15 @@ impl Part for RestMethodMediaUploadProtocolsSimple {} /// let rb = hub.apis(); /// # } /// ``` -pub struct ApiMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ApiMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Discovery, + hub: &'a Discovery, } -impl<'a, C, NC, A> MethodsBuilder for ApiMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ApiMethods<'a, C, A> {} -impl<'a, C, NC, A> ApiMethods<'a, C, NC, A> { +impl<'a, C, A> ApiMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -836,7 +832,7 @@ impl<'a, C, NC, A> ApiMethods<'a, C, NC, A> { /// /// * `api` - The name of the API. /// * `version` - The version of the API. - pub fn get_rest(&self, api: &str, version: &str) -> ApiGetRestCall<'a, C, NC, A> { + pub fn get_rest(&self, api: &str, version: &str) -> ApiGetRestCall<'a, C, A> { ApiGetRestCall { hub: self.hub, _api: api.to_string(), @@ -849,7 +845,7 @@ impl<'a, C, NC, A> ApiMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Retrieve the list of APIs supported at this endpoint. - pub fn list(&self) -> ApiListCall<'a, C, NC, A> { + pub fn list(&self) -> ApiListCall<'a, C, A> { ApiListCall { hub: self.hub, _preferred: Default::default(), @@ -898,19 +894,19 @@ impl<'a, C, NC, A> ApiMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct ApiGetRestCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ApiGetRestCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Discovery, + hub: &'a Discovery, _api: String, _version: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for ApiGetRestCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ApiGetRestCall<'a, C, A> {} -impl<'a, C, NC, A> ApiGetRestCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ApiGetRestCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1041,7 +1037,7 @@ impl<'a, C, NC, A> ApiGetRestCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The name of the API. - pub fn api(mut self, new_value: &str) -> ApiGetRestCall<'a, C, NC, A> { + pub fn api(mut self, new_value: &str) -> ApiGetRestCall<'a, C, A> { self._api = new_value.to_string(); self } @@ -1051,7 +1047,7 @@ impl<'a, C, NC, A> ApiGetRestCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The version of the API. - pub fn version(mut self, new_value: &str) -> ApiGetRestCall<'a, C, NC, A> { + pub fn version(mut self, new_value: &str) -> ApiGetRestCall<'a, C, A> { self._version = new_value.to_string(); self } @@ -1062,7 +1058,7 @@ impl<'a, C, NC, A> ApiGetRestCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ApiGetRestCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ApiGetRestCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1083,7 +1079,7 @@ impl<'a, C, NC, A> ApiGetRestCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ApiGetRestCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ApiGetRestCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1124,19 +1120,19 @@ impl<'a, C, NC, A> ApiGetRestCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct ApiListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ApiListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Discovery, + hub: &'a Discovery, _preferred: Option, _name: Option, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for ApiListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ApiListCall<'a, C, A> {} -impl<'a, C, NC, A> ApiListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ApiListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1245,7 +1241,7 @@ impl<'a, C, NC, A> ApiListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Return only the preferred version of an API. - pub fn preferred(mut self, new_value: bool) -> ApiListCall<'a, C, NC, A> { + pub fn preferred(mut self, new_value: bool) -> ApiListCall<'a, C, A> { self._preferred = Some(new_value); self } @@ -1253,7 +1249,7 @@ impl<'a, C, NC, A> ApiListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Only include APIs with the given name. - pub fn name(mut self, new_value: &str) -> ApiListCall<'a, C, NC, A> { + pub fn name(mut self, new_value: &str) -> ApiListCall<'a, C, A> { self._name = Some(new_value.to_string()); self } @@ -1264,7 +1260,7 @@ impl<'a, C, NC, A> ApiListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ApiListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ApiListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1285,7 +1281,7 @@ impl<'a, C, NC, A> ApiListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ApiListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ApiListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self diff --git a/gen/dns1_beta1/Cargo.toml b/gen/dns1_beta1/Cargo.toml index f312167860b..5e5ef6aa35b 100644 --- a/gen/dns1_beta1/Cargo.toml +++ b/gen/dns1_beta1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-dns1_beta1" -version = "0.1.4+20150114" +version = "0.1.5+20150114" authors = ["Sebastian Thiel "] description = "A complete library to interact with dns (protocol v1beta1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/dns1_beta1" homepage = "https://developers.google.com/cloud-dns" -documentation = "http://byron.github.io/google-apis-rs/google-dns1_beta1" +documentation = "http://byron.github.io/google-apis-rs/google_dns1_beta1" license = "MIT" keywords = ["dns", "google", "protocol", "web", "api"] diff --git a/gen/dns1_beta1/README.md b/gen/dns1_beta1/README.md index 428e56cfbaa..1c47842e4de 100644 --- a/gen/dns1_beta1/README.md +++ b/gen/dns1_beta1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-dns1_beta1` library allows access to all features of the *Google dns* service. -This documentation was generated from *dns* crate version *0.1.4+20150114*, where *20150114* is the exact revision of the *dns:v1beta1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *dns* crate version *0.1.5+20150114*, where *20150114* is the exact revision of the *dns:v1beta1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *dns* *v1_beta1* API can be found at the [official documentation site](https://developers.google.com/cloud-dns). diff --git a/gen/dns1_beta1/src/cmn.rs b/gen/dns1_beta1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/dns1_beta1/src/cmn.rs +++ b/gen/dns1_beta1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/dns1_beta1/src/lib.rs b/gen/dns1_beta1/src/lib.rs index 4ae784c316f..22097bb5353 100644 --- a/gen/dns1_beta1/src/lib.rs +++ b/gen/dns1_beta1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *dns* crate version *0.1.4+20150114*, where *20150114* is the exact revision of the *dns:v1beta1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *dns* crate version *0.1.5+20150114*, where *20150114* is the exact revision of the *dns:v1beta1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *dns* *v1_beta1* API can be found at the //! [official documentation site](https://developers.google.com/cloud-dns). @@ -199,7 +199,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -300,43 +299,40 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Dns { +pub struct Dns { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Dns {} +impl<'a, C, A> Hub for Dns {} -impl<'a, C, NC, A> Dns - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Dns + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Dns { + pub fn new(client: C, authenticator: A) -> Dns { Dns { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn changes(&'a self) -> ChangeMethods<'a, C, NC, A> { + pub fn changes(&'a self) -> ChangeMethods<'a, C, A> { ChangeMethods { hub: &self } } - pub fn managed_zones(&'a self) -> ManagedZoneMethods<'a, C, NC, A> { + pub fn managed_zones(&'a self) -> ManagedZoneMethods<'a, C, A> { ManagedZoneMethods { hub: &self } } - pub fn projects(&'a self) -> ProjectMethods<'a, C, NC, A> { + pub fn projects(&'a self) -> ProjectMethods<'a, C, A> { ProjectMethods { hub: &self } } - pub fn resource_record_sets(&'a self) -> ResourceRecordSetMethods<'a, C, NC, A> { + pub fn resource_record_sets(&'a self) -> ResourceRecordSetMethods<'a, C, A> { ResourceRecordSetMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -616,15 +612,15 @@ impl ResponseResult for ResourceRecordSetsListResponse {} /// let rb = hub.changes(); /// # } /// ``` -pub struct ChangeMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChangeMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dns, + hub: &'a Dns, } -impl<'a, C, NC, A> MethodsBuilder for ChangeMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ChangeMethods<'a, C, A> {} -impl<'a, C, NC, A> ChangeMethods<'a, C, NC, A> { +impl<'a, C, A> ChangeMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -635,7 +631,7 @@ impl<'a, C, NC, A> ChangeMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Identifies the project addressed by this request. /// * `managedZone` - Identifies the managed zone addressed by this request. Can be the managed zone name or id. - pub fn create(&self, request: &Change, project: &str, managed_zone: &str) -> ChangeCreateCall<'a, C, NC, A> { + pub fn create(&self, request: &Change, project: &str, managed_zone: &str) -> ChangeCreateCall<'a, C, A> { ChangeCreateCall { hub: self.hub, _request: request.clone(), @@ -655,7 +651,7 @@ impl<'a, C, NC, A> ChangeMethods<'a, C, NC, A> { /// /// * `project` - Identifies the project addressed by this request. /// * `managedZone` - Identifies the managed zone addressed by this request. Can be the managed zone name or id. - pub fn list(&self, project: &str, managed_zone: &str) -> ChangeListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, managed_zone: &str) -> ChangeListCall<'a, C, A> { ChangeListCall { hub: self.hub, _project: project.to_string(), @@ -679,7 +675,7 @@ impl<'a, C, NC, A> ChangeMethods<'a, C, NC, A> { /// * `project` - Identifies the project addressed by this request. /// * `managedZone` - Identifies the managed zone addressed by this request. Can be the managed zone name or id. /// * `changeId` - The identifier of the requested change, from a previous ResourceRecordSetsChangeResponse. - pub fn get(&self, project: &str, managed_zone: &str, change_id: &str) -> ChangeGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, managed_zone: &str, change_id: &str) -> ChangeGetCall<'a, C, A> { ChangeGetCall { hub: self.hub, _project: project.to_string(), @@ -722,15 +718,15 @@ impl<'a, C, NC, A> ChangeMethods<'a, C, NC, A> { /// let rb = hub.managed_zones(); /// # } /// ``` -pub struct ManagedZoneMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagedZoneMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dns, + hub: &'a Dns, } -impl<'a, C, NC, A> MethodsBuilder for ManagedZoneMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ManagedZoneMethods<'a, C, A> {} -impl<'a, C, NC, A> ManagedZoneMethods<'a, C, NC, A> { +impl<'a, C, A> ManagedZoneMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -740,7 +736,7 @@ impl<'a, C, NC, A> ManagedZoneMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `project` - Identifies the project addressed by this request. - pub fn create(&self, request: &ManagedZone, project: &str) -> ManagedZoneCreateCall<'a, C, NC, A> { + pub fn create(&self, request: &ManagedZone, project: &str) -> ManagedZoneCreateCall<'a, C, A> { ManagedZoneCreateCall { hub: self.hub, _request: request.clone(), @@ -759,7 +755,7 @@ impl<'a, C, NC, A> ManagedZoneMethods<'a, C, NC, A> { /// /// * `project` - Identifies the project addressed by this request. /// * `managedZone` - Identifies the managed zone addressed by this request. Can be the managed zone name or id. - pub fn delete(&self, project: &str, managed_zone: &str) -> ManagedZoneDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, managed_zone: &str) -> ManagedZoneDeleteCall<'a, C, A> { ManagedZoneDeleteCall { hub: self.hub, _project: project.to_string(), @@ -778,7 +774,7 @@ impl<'a, C, NC, A> ManagedZoneMethods<'a, C, NC, A> { /// /// * `project` - Identifies the project addressed by this request. /// * `managedZone` - Identifies the managed zone addressed by this request. Can be the managed zone name or id. - pub fn get(&self, project: &str, managed_zone: &str) -> ManagedZoneGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, managed_zone: &str) -> ManagedZoneGetCall<'a, C, A> { ManagedZoneGetCall { hub: self.hub, _project: project.to_string(), @@ -796,7 +792,7 @@ impl<'a, C, NC, A> ManagedZoneMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Identifies the project addressed by this request. - pub fn list(&self, project: &str) -> ManagedZoneListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> ManagedZoneListCall<'a, C, A> { ManagedZoneListCall { hub: self.hub, _project: project.to_string(), @@ -839,15 +835,15 @@ impl<'a, C, NC, A> ManagedZoneMethods<'a, C, NC, A> { /// let rb = hub.resource_record_sets(); /// # } /// ``` -pub struct ResourceRecordSetMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ResourceRecordSetMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dns, + hub: &'a Dns, } -impl<'a, C, NC, A> MethodsBuilder for ResourceRecordSetMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ResourceRecordSetMethods<'a, C, A> {} -impl<'a, C, NC, A> ResourceRecordSetMethods<'a, C, NC, A> { +impl<'a, C, A> ResourceRecordSetMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -857,7 +853,7 @@ impl<'a, C, NC, A> ResourceRecordSetMethods<'a, C, NC, A> { /// /// * `project` - Identifies the project addressed by this request. /// * `managedZone` - Identifies the managed zone addressed by this request. Can be the managed zone name or id. - pub fn list(&self, project: &str, managed_zone: &str) -> ResourceRecordSetListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, managed_zone: &str) -> ResourceRecordSetListCall<'a, C, A> { ResourceRecordSetListCall { hub: self.hub, _project: project.to_string(), @@ -903,15 +899,15 @@ impl<'a, C, NC, A> ResourceRecordSetMethods<'a, C, NC, A> { /// let rb = hub.projects(); /// # } /// ``` -pub struct ProjectMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dns, + hub: &'a Dns, } -impl<'a, C, NC, A> MethodsBuilder for ProjectMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ProjectMethods<'a, C, A> {} -impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { +impl<'a, C, A> ProjectMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -920,7 +916,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Identifies the project addressed by this request. - pub fn get(&self, project: &str) -> ProjectGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str) -> ProjectGetCall<'a, C, A> { ProjectGetCall { hub: self.hub, _project: project.to_string(), @@ -975,10 +971,10 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct ChangeCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChangeCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dns, + hub: &'a Dns, _request: Change, _project: String, _managed_zone: String, @@ -987,9 +983,9 @@ pub struct ChangeCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChangeCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChangeCreateCall<'a, C, A> {} -impl<'a, C, NC, A> ChangeCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChangeCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1129,7 +1125,7 @@ impl<'a, C, NC, A> ChangeCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Change) -> ChangeCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Change) -> ChangeCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1139,7 +1135,7 @@ impl<'a, C, NC, A> ChangeCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Identifies the project addressed by this request. - pub fn project(mut self, new_value: &str) -> ChangeCreateCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ChangeCreateCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1149,7 +1145,7 @@ impl<'a, C, NC, A> ChangeCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Identifies the managed zone addressed by this request. Can be the managed zone name or id. - pub fn managed_zone(mut self, new_value: &str) -> ChangeCreateCall<'a, C, NC, A> { + pub fn managed_zone(mut self, new_value: &str) -> ChangeCreateCall<'a, C, A> { self._managed_zone = new_value.to_string(); self } @@ -1160,7 +1156,7 @@ impl<'a, C, NC, A> ChangeCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChangeCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChangeCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1181,7 +1177,7 @@ impl<'a, C, NC, A> ChangeCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChangeCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChangeCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1198,7 +1194,7 @@ impl<'a, C, NC, A> ChangeCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChangeCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChangeCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1240,10 +1236,10 @@ impl<'a, C, NC, A> ChangeCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct ChangeListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChangeListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dns, + hub: &'a Dns, _project: String, _managed_zone: String, _sort_order: Option, @@ -1255,9 +1251,9 @@ pub struct ChangeListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChangeListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChangeListCall<'a, C, A> {} -impl<'a, C, NC, A> ChangeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChangeListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1402,7 +1398,7 @@ impl<'a, C, NC, A> ChangeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Identifies the project addressed by this request. - pub fn project(mut self, new_value: &str) -> ChangeListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ChangeListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1412,7 +1408,7 @@ impl<'a, C, NC, A> ChangeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Identifies the managed zone addressed by this request. Can be the managed zone name or id. - pub fn managed_zone(mut self, new_value: &str) -> ChangeListCall<'a, C, NC, A> { + pub fn managed_zone(mut self, new_value: &str) -> ChangeListCall<'a, C, A> { self._managed_zone = new_value.to_string(); self } @@ -1420,7 +1416,7 @@ impl<'a, C, NC, A> ChangeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Sorting order direction: 'ascending' or 'descending'. - pub fn sort_order(mut self, new_value: &str) -> ChangeListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> ChangeListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -1428,7 +1424,7 @@ impl<'a, C, NC, A> ChangeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Sorting criterion. The only supported value is change sequence. - pub fn sort_by(mut self, new_value: &str) -> ChangeListCall<'a, C, NC, A> { + pub fn sort_by(mut self, new_value: &str) -> ChangeListCall<'a, C, A> { self._sort_by = Some(new_value.to_string()); self } @@ -1436,7 +1432,7 @@ impl<'a, C, NC, A> ChangeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Optional. A tag returned by a previous list request that was truncated. Use this parameter to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> ChangeListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ChangeListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -1444,7 +1440,7 @@ impl<'a, C, NC, A> ChangeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Optional. Maximum number of results to be returned. If unspecified, the server will decide how many results to return. - pub fn max_results(mut self, new_value: i32) -> ChangeListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ChangeListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -1455,7 +1451,7 @@ impl<'a, C, NC, A> ChangeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChangeListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChangeListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1476,7 +1472,7 @@ impl<'a, C, NC, A> ChangeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChangeListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChangeListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1493,7 +1489,7 @@ impl<'a, C, NC, A> ChangeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChangeListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChangeListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1531,10 +1527,10 @@ impl<'a, C, NC, A> ChangeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct ChangeGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChangeGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dns, + hub: &'a Dns, _project: String, _managed_zone: String, _change_id: String, @@ -1543,9 +1539,9 @@ pub struct ChangeGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChangeGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChangeGetCall<'a, C, A> {} -impl<'a, C, NC, A> ChangeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChangeGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1679,7 +1675,7 @@ impl<'a, C, NC, A> ChangeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Identifies the project addressed by this request. - pub fn project(mut self, new_value: &str) -> ChangeGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ChangeGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1689,7 +1685,7 @@ impl<'a, C, NC, A> ChangeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Identifies the managed zone addressed by this request. Can be the managed zone name or id. - pub fn managed_zone(mut self, new_value: &str) -> ChangeGetCall<'a, C, NC, A> { + pub fn managed_zone(mut self, new_value: &str) -> ChangeGetCall<'a, C, A> { self._managed_zone = new_value.to_string(); self } @@ -1699,7 +1695,7 @@ impl<'a, C, NC, A> ChangeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The identifier of the requested change, from a previous ResourceRecordSetsChangeResponse. - pub fn change_id(mut self, new_value: &str) -> ChangeGetCall<'a, C, NC, A> { + pub fn change_id(mut self, new_value: &str) -> ChangeGetCall<'a, C, A> { self._change_id = new_value.to_string(); self } @@ -1710,7 +1706,7 @@ impl<'a, C, NC, A> ChangeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChangeGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChangeGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1731,7 +1727,7 @@ impl<'a, C, NC, A> ChangeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChangeGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChangeGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1748,7 +1744,7 @@ impl<'a, C, NC, A> ChangeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChangeGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChangeGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1792,10 +1788,10 @@ impl<'a, C, NC, A> ChangeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct ManagedZoneCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagedZoneCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dns, + hub: &'a Dns, _request: ManagedZone, _project: String, _delegate: Option<&'a mut Delegate>, @@ -1803,9 +1799,9 @@ pub struct ManagedZoneCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagedZoneCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagedZoneCreateCall<'a, C, A> {} -impl<'a, C, NC, A> ManagedZoneCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagedZoneCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1944,7 +1940,7 @@ impl<'a, C, NC, A> ManagedZoneCreateCall<'a, C, NC, A> where NC: hyper::net::Net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ManagedZone) -> ManagedZoneCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ManagedZone) -> ManagedZoneCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1954,7 +1950,7 @@ impl<'a, C, NC, A> ManagedZoneCreateCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Identifies the project addressed by this request. - pub fn project(mut self, new_value: &str) -> ManagedZoneCreateCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ManagedZoneCreateCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1965,7 +1961,7 @@ impl<'a, C, NC, A> ManagedZoneCreateCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagedZoneCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagedZoneCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1986,7 +1982,7 @@ impl<'a, C, NC, A> ManagedZoneCreateCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagedZoneCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagedZoneCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2003,7 +1999,7 @@ impl<'a, C, NC, A> ManagedZoneCreateCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagedZoneCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagedZoneCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2041,10 +2037,10 @@ impl<'a, C, NC, A> ManagedZoneCreateCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct ManagedZoneDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagedZoneDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dns, + hub: &'a Dns, _project: String, _managed_zone: String, _delegate: Option<&'a mut Delegate>, @@ -2052,9 +2048,9 @@ pub struct ManagedZoneDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagedZoneDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagedZoneDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ManagedZoneDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagedZoneDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2176,7 +2172,7 @@ impl<'a, C, NC, A> ManagedZoneDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Identifies the project addressed by this request. - pub fn project(mut self, new_value: &str) -> ManagedZoneDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ManagedZoneDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2186,7 +2182,7 @@ impl<'a, C, NC, A> ManagedZoneDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Identifies the managed zone addressed by this request. Can be the managed zone name or id. - pub fn managed_zone(mut self, new_value: &str) -> ManagedZoneDeleteCall<'a, C, NC, A> { + pub fn managed_zone(mut self, new_value: &str) -> ManagedZoneDeleteCall<'a, C, A> { self._managed_zone = new_value.to_string(); self } @@ -2197,7 +2193,7 @@ impl<'a, C, NC, A> ManagedZoneDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagedZoneDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagedZoneDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2218,7 +2214,7 @@ impl<'a, C, NC, A> ManagedZoneDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagedZoneDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagedZoneDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2235,7 +2231,7 @@ impl<'a, C, NC, A> ManagedZoneDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagedZoneDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagedZoneDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2273,10 +2269,10 @@ impl<'a, C, NC, A> ManagedZoneDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct ManagedZoneGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagedZoneGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dns, + hub: &'a Dns, _project: String, _managed_zone: String, _delegate: Option<&'a mut Delegate>, @@ -2284,9 +2280,9 @@ pub struct ManagedZoneGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagedZoneGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagedZoneGetCall<'a, C, A> {} -impl<'a, C, NC, A> ManagedZoneGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagedZoneGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2419,7 +2415,7 @@ impl<'a, C, NC, A> ManagedZoneGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Identifies the project addressed by this request. - pub fn project(mut self, new_value: &str) -> ManagedZoneGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ManagedZoneGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2429,7 +2425,7 @@ impl<'a, C, NC, A> ManagedZoneGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Identifies the managed zone addressed by this request. Can be the managed zone name or id. - pub fn managed_zone(mut self, new_value: &str) -> ManagedZoneGetCall<'a, C, NC, A> { + pub fn managed_zone(mut self, new_value: &str) -> ManagedZoneGetCall<'a, C, A> { self._managed_zone = new_value.to_string(); self } @@ -2440,7 +2436,7 @@ impl<'a, C, NC, A> ManagedZoneGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagedZoneGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagedZoneGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2461,7 +2457,7 @@ impl<'a, C, NC, A> ManagedZoneGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagedZoneGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagedZoneGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2478,7 +2474,7 @@ impl<'a, C, NC, A> ManagedZoneGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagedZoneGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagedZoneGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2518,10 +2514,10 @@ impl<'a, C, NC, A> ManagedZoneGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct ManagedZoneListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ManagedZoneListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dns, + hub: &'a Dns, _project: String, _page_token: Option, _max_results: Option, @@ -2530,9 +2526,9 @@ pub struct ManagedZoneListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ManagedZoneListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ManagedZoneListCall<'a, C, A> {} -impl<'a, C, NC, A> ManagedZoneListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ManagedZoneListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2670,7 +2666,7 @@ impl<'a, C, NC, A> ManagedZoneListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Identifies the project addressed by this request. - pub fn project(mut self, new_value: &str) -> ManagedZoneListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ManagedZoneListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2678,7 +2674,7 @@ impl<'a, C, NC, A> ManagedZoneListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Optional. A tag returned by a previous list request that was truncated. Use this parameter to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> ManagedZoneListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ManagedZoneListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2686,7 +2682,7 @@ impl<'a, C, NC, A> ManagedZoneListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Optional. Maximum number of results to be returned. If unspecified, the server will decide how many results to return. - pub fn max_results(mut self, new_value: i32) -> ManagedZoneListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ManagedZoneListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2697,7 +2693,7 @@ impl<'a, C, NC, A> ManagedZoneListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagedZoneListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManagedZoneListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2718,7 +2714,7 @@ impl<'a, C, NC, A> ManagedZoneListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ManagedZoneListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ManagedZoneListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2735,7 +2731,7 @@ impl<'a, C, NC, A> ManagedZoneListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ManagedZoneListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ManagedZoneListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2777,10 +2773,10 @@ impl<'a, C, NC, A> ManagedZoneListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct ResourceRecordSetListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ResourceRecordSetListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dns, + hub: &'a Dns, _project: String, _managed_zone: String, _type_: Option, @@ -2792,9 +2788,9 @@ pub struct ResourceRecordSetListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ResourceRecordSetListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ResourceRecordSetListCall<'a, C, A> {} -impl<'a, C, NC, A> ResourceRecordSetListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ResourceRecordSetListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2939,7 +2935,7 @@ impl<'a, C, NC, A> ResourceRecordSetListCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Identifies the project addressed by this request. - pub fn project(mut self, new_value: &str) -> ResourceRecordSetListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ResourceRecordSetListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2949,7 +2945,7 @@ impl<'a, C, NC, A> ResourceRecordSetListCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Identifies the managed zone addressed by this request. Can be the managed zone name or id. - pub fn managed_zone(mut self, new_value: &str) -> ResourceRecordSetListCall<'a, C, NC, A> { + pub fn managed_zone(mut self, new_value: &str) -> ResourceRecordSetListCall<'a, C, A> { self._managed_zone = new_value.to_string(); self } @@ -2957,7 +2953,7 @@ impl<'a, C, NC, A> ResourceRecordSetListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Restricts the list to return only records of this type. If present, the "name" parameter must also be present. - pub fn type_(mut self, new_value: &str) -> ResourceRecordSetListCall<'a, C, NC, A> { + pub fn type_(mut self, new_value: &str) -> ResourceRecordSetListCall<'a, C, A> { self._type_ = Some(new_value.to_string()); self } @@ -2965,7 +2961,7 @@ impl<'a, C, NC, A> ResourceRecordSetListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Optional. A tag returned by a previous list request that was truncated. Use this parameter to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> ResourceRecordSetListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ResourceRecordSetListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2973,7 +2969,7 @@ impl<'a, C, NC, A> ResourceRecordSetListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Restricts the list to return only records with this fully qualified domain name. - pub fn name(mut self, new_value: &str) -> ResourceRecordSetListCall<'a, C, NC, A> { + pub fn name(mut self, new_value: &str) -> ResourceRecordSetListCall<'a, C, A> { self._name = Some(new_value.to_string()); self } @@ -2981,7 +2977,7 @@ impl<'a, C, NC, A> ResourceRecordSetListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// Optional. Maximum number of results to be returned. If unspecified, the server will decide how many results to return. - pub fn max_results(mut self, new_value: i32) -> ResourceRecordSetListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ResourceRecordSetListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2992,7 +2988,7 @@ impl<'a, C, NC, A> ResourceRecordSetListCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ResourceRecordSetListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ResourceRecordSetListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3013,7 +3009,7 @@ impl<'a, C, NC, A> ResourceRecordSetListCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ResourceRecordSetListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ResourceRecordSetListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3030,7 +3026,7 @@ impl<'a, C, NC, A> ResourceRecordSetListCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ResourceRecordSetListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ResourceRecordSetListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3068,19 +3064,19 @@ impl<'a, C, NC, A> ResourceRecordSetListCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct ProjectGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Dns, + hub: &'a Dns, _project: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectGetCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3212,7 +3208,7 @@ impl<'a, C, NC, A> ProjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Identifies the project addressed by this request. - pub fn project(mut self, new_value: &str) -> ProjectGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ProjectGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -3223,7 +3219,7 @@ impl<'a, C, NC, A> ProjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3244,7 +3240,7 @@ impl<'a, C, NC, A> ProjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3261,7 +3257,7 @@ impl<'a, C, NC, A> ProjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/doubleclickbidmanager1/Cargo.toml b/gen/doubleclickbidmanager1/Cargo.toml index 5b2b7e6aaed..f9c5903fc49 100644 --- a/gen/doubleclickbidmanager1/Cargo.toml +++ b/gen/doubleclickbidmanager1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-doubleclickbidmanager1" -version = "0.1.4+20150326" +version = "0.1.5+20150326" authors = ["Sebastian Thiel "] description = "A complete library to interact with DoubleClick Bid Manager (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/doubleclickbidmanager1" homepage = "https://developers.google.com/bid-manager/" -documentation = "http://byron.github.io/google-apis-rs/google-doubleclickbidmanager1" +documentation = "http://byron.github.io/google-apis-rs/google_doubleclickbidmanager1" license = "MIT" keywords = ["doubleclickbidmanage", "google", "protocol", "web", "api"] diff --git a/gen/doubleclickbidmanager1/README.md b/gen/doubleclickbidmanager1/README.md index 8ee5b04bd3e..fff4890e764 100644 --- a/gen/doubleclickbidmanager1/README.md +++ b/gen/doubleclickbidmanager1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-doubleclickbidmanager1` library allows access to all features of the *Google DoubleClick Bid Manager* service. -This documentation was generated from *DoubleClick Bid Manager* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *doubleclickbidmanager:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *DoubleClick Bid Manager* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *doubleclickbidmanager:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *DoubleClick Bid Manager* *v1* API can be found at the [official documentation site](https://developers.google.com/bid-manager/). diff --git a/gen/doubleclickbidmanager1/src/cmn.rs b/gen/doubleclickbidmanager1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/doubleclickbidmanager1/src/cmn.rs +++ b/gen/doubleclickbidmanager1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/doubleclickbidmanager1/src/lib.rs b/gen/doubleclickbidmanager1/src/lib.rs index 6d8f128ea08..61a7e18abe3 100644 --- a/gen/doubleclickbidmanager1/src/lib.rs +++ b/gen/doubleclickbidmanager1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *DoubleClick Bid Manager* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *doubleclickbidmanager:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *DoubleClick Bid Manager* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *doubleclickbidmanager:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *DoubleClick Bid Manager* *v1* API can be found at the //! [official documentation site](https://developers.google.com/bid-manager/). @@ -193,7 +193,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -262,40 +261,37 @@ pub use cmn::{MultiPartReader, ToParts, MethodInfo, Result, Error, CallBuilder, /// } /// # } /// ``` -pub struct DoubleClickBidManager { +pub struct DoubleClickBidManager { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for DoubleClickBidManager {} +impl<'a, C, A> Hub for DoubleClickBidManager {} -impl<'a, C, NC, A> DoubleClickBidManager - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DoubleClickBidManager + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> DoubleClickBidManager { + pub fn new(client: C, authenticator: A) -> DoubleClickBidManager { DoubleClickBidManager { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn lineitems(&'a self) -> LineitemMethods<'a, C, NC, A> { + pub fn lineitems(&'a self) -> LineitemMethods<'a, C, A> { LineitemMethods { hub: &self } } - pub fn queries(&'a self) -> QueryMethods<'a, C, NC, A> { + pub fn queries(&'a self) -> QueryMethods<'a, C, A> { QueryMethods { hub: &self } } - pub fn reports(&'a self) -> ReportMethods<'a, C, NC, A> { + pub fn reports(&'a self) -> ReportMethods<'a, C, A> { ReportMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -775,15 +771,15 @@ impl Part for UploadStatus {} /// let rb = hub.lineitems(); /// # } /// ``` -pub struct LineitemMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LineitemMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a DoubleClickBidManager, + hub: &'a DoubleClickBidManager, } -impl<'a, C, NC, A> MethodsBuilder for LineitemMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for LineitemMethods<'a, C, A> {} -impl<'a, C, NC, A> LineitemMethods<'a, C, NC, A> { +impl<'a, C, A> LineitemMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -792,7 +788,7 @@ impl<'a, C, NC, A> LineitemMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn uploadlineitems(&self, request: &UploadLineItemsRequest) -> LineitemUploadlineitemCall<'a, C, NC, A> { + pub fn uploadlineitems(&self, request: &UploadLineItemsRequest) -> LineitemUploadlineitemCall<'a, C, A> { LineitemUploadlineitemCall { hub: self.hub, _request: request.clone(), @@ -808,7 +804,7 @@ impl<'a, C, NC, A> LineitemMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn downloadlineitems(&self, request: &DownloadLineItemsRequest) -> LineitemDownloadlineitemCall<'a, C, NC, A> { + pub fn downloadlineitems(&self, request: &DownloadLineItemsRequest) -> LineitemDownloadlineitemCall<'a, C, A> { LineitemDownloadlineitemCall { hub: self.hub, _request: request.clone(), @@ -848,15 +844,15 @@ impl<'a, C, NC, A> LineitemMethods<'a, C, NC, A> { /// let rb = hub.reports(); /// # } /// ``` -pub struct ReportMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a DoubleClickBidManager, + hub: &'a DoubleClickBidManager, } -impl<'a, C, NC, A> MethodsBuilder for ReportMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ReportMethods<'a, C, A> {} -impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { +impl<'a, C, A> ReportMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -865,7 +861,7 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// # Arguments /// /// * `queryId` - Query ID with which the reports are associated. - pub fn listreports(&self, query_id: &str) -> ReportListreportCall<'a, C, NC, A> { + pub fn listreports(&self, query_id: &str) -> ReportListreportCall<'a, C, A> { ReportListreportCall { hub: self.hub, _query_id: query_id.to_string(), @@ -905,20 +901,20 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// let rb = hub.queries(); /// # } /// ``` -pub struct QueryMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct QueryMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a DoubleClickBidManager, + hub: &'a DoubleClickBidManager, } -impl<'a, C, NC, A> MethodsBuilder for QueryMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for QueryMethods<'a, C, A> {} -impl<'a, C, NC, A> QueryMethods<'a, C, NC, A> { +impl<'a, C, A> QueryMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Retrieves stored queries. - pub fn listqueries(&self) -> QueryListqueryCall<'a, C, NC, A> { + pub fn listqueries(&self) -> QueryListqueryCall<'a, C, A> { QueryListqueryCall { hub: self.hub, _delegate: Default::default(), @@ -933,7 +929,7 @@ impl<'a, C, NC, A> QueryMethods<'a, C, NC, A> { /// # Arguments /// /// * `queryId` - Query ID to retrieve. - pub fn getquery(&self, query_id: &str) -> QueryGetqueryCall<'a, C, NC, A> { + pub fn getquery(&self, query_id: &str) -> QueryGetqueryCall<'a, C, A> { QueryGetqueryCall { hub: self.hub, _query_id: query_id.to_string(), @@ -949,7 +945,7 @@ impl<'a, C, NC, A> QueryMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn createquery(&self, request: &Query) -> QueryCreatequeryCall<'a, C, NC, A> { + pub fn createquery(&self, request: &Query) -> QueryCreatequeryCall<'a, C, A> { QueryCreatequeryCall { hub: self.hub, _request: request.clone(), @@ -965,7 +961,7 @@ impl<'a, C, NC, A> QueryMethods<'a, C, NC, A> { /// # Arguments /// /// * `queryId` - Query ID to delete. - pub fn deletequery(&self, query_id: &str) -> QueryDeletequeryCall<'a, C, NC, A> { + pub fn deletequery(&self, query_id: &str) -> QueryDeletequeryCall<'a, C, A> { QueryDeletequeryCall { hub: self.hub, _query_id: query_id.to_string(), @@ -982,7 +978,7 @@ impl<'a, C, NC, A> QueryMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `queryId` - Query ID to run. - pub fn runquery(&self, request: &RunQueryRequest, query_id: &str) -> QueryRunqueryCall<'a, C, NC, A> { + pub fn runquery(&self, request: &RunQueryRequest, query_id: &str) -> QueryRunqueryCall<'a, C, A> { QueryRunqueryCall { hub: self.hub, _request: request.clone(), @@ -1037,18 +1033,18 @@ impl<'a, C, NC, A> QueryMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct LineitemUploadlineitemCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LineitemUploadlineitemCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a DoubleClickBidManager, + hub: &'a DoubleClickBidManager, _request: UploadLineItemsRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for LineitemUploadlineitemCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LineitemUploadlineitemCall<'a, C, A> {} -impl<'a, C, NC, A> LineitemUploadlineitemCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LineitemUploadlineitemCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1160,7 +1156,7 @@ impl<'a, C, NC, A> LineitemUploadlineitemCall<'a, C, NC, A> where NC: hyper::net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &UploadLineItemsRequest) -> LineitemUploadlineitemCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &UploadLineItemsRequest) -> LineitemUploadlineitemCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1171,7 +1167,7 @@ impl<'a, C, NC, A> LineitemUploadlineitemCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LineitemUploadlineitemCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LineitemUploadlineitemCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1192,7 +1188,7 @@ impl<'a, C, NC, A> LineitemUploadlineitemCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LineitemUploadlineitemCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LineitemUploadlineitemCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1237,18 +1233,18 @@ impl<'a, C, NC, A> LineitemUploadlineitemCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct LineitemDownloadlineitemCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LineitemDownloadlineitemCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a DoubleClickBidManager, + hub: &'a DoubleClickBidManager, _request: DownloadLineItemsRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for LineitemDownloadlineitemCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LineitemDownloadlineitemCall<'a, C, A> {} -impl<'a, C, NC, A> LineitemDownloadlineitemCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LineitemDownloadlineitemCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1360,7 +1356,7 @@ impl<'a, C, NC, A> LineitemDownloadlineitemCall<'a, C, NC, A> where NC: hyper::n /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &DownloadLineItemsRequest) -> LineitemDownloadlineitemCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &DownloadLineItemsRequest) -> LineitemDownloadlineitemCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1371,7 +1367,7 @@ impl<'a, C, NC, A> LineitemDownloadlineitemCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LineitemDownloadlineitemCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LineitemDownloadlineitemCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1392,7 +1388,7 @@ impl<'a, C, NC, A> LineitemDownloadlineitemCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LineitemDownloadlineitemCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LineitemDownloadlineitemCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1431,18 +1427,18 @@ impl<'a, C, NC, A> LineitemDownloadlineitemCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct ReportListreportCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportListreportCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a DoubleClickBidManager, + hub: &'a DoubleClickBidManager, _query_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for ReportListreportCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReportListreportCall<'a, C, A> {} -impl<'a, C, NC, A> ReportListreportCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReportListreportCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1572,7 +1568,7 @@ impl<'a, C, NC, A> ReportListreportCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Query ID with which the reports are associated. - pub fn query_id(mut self, new_value: &str) -> ReportListreportCall<'a, C, NC, A> { + pub fn query_id(mut self, new_value: &str) -> ReportListreportCall<'a, C, A> { self._query_id = new_value.to_string(); self } @@ -1583,7 +1579,7 @@ impl<'a, C, NC, A> ReportListreportCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportListreportCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportListreportCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1604,7 +1600,7 @@ impl<'a, C, NC, A> ReportListreportCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReportListreportCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReportListreportCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1643,17 +1639,17 @@ impl<'a, C, NC, A> ReportListreportCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct QueryListqueryCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct QueryListqueryCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a DoubleClickBidManager, + hub: &'a DoubleClickBidManager, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for QueryListqueryCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for QueryListqueryCall<'a, C, A> {} -impl<'a, C, NC, A> QueryListqueryCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> QueryListqueryCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1759,7 +1755,7 @@ impl<'a, C, NC, A> QueryListqueryCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> QueryListqueryCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> QueryListqueryCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1780,7 +1776,7 @@ impl<'a, C, NC, A> QueryListqueryCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> QueryListqueryCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> QueryListqueryCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1819,18 +1815,18 @@ impl<'a, C, NC, A> QueryListqueryCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct QueryGetqueryCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct QueryGetqueryCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a DoubleClickBidManager, + hub: &'a DoubleClickBidManager, _query_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for QueryGetqueryCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for QueryGetqueryCall<'a, C, A> {} -impl<'a, C, NC, A> QueryGetqueryCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> QueryGetqueryCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1960,7 +1956,7 @@ impl<'a, C, NC, A> QueryGetqueryCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Query ID to retrieve. - pub fn query_id(mut self, new_value: &str) -> QueryGetqueryCall<'a, C, NC, A> { + pub fn query_id(mut self, new_value: &str) -> QueryGetqueryCall<'a, C, A> { self._query_id = new_value.to_string(); self } @@ -1971,7 +1967,7 @@ impl<'a, C, NC, A> QueryGetqueryCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> QueryGetqueryCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> QueryGetqueryCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1992,7 +1988,7 @@ impl<'a, C, NC, A> QueryGetqueryCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> QueryGetqueryCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> QueryGetqueryCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2037,18 +2033,18 @@ impl<'a, C, NC, A> QueryGetqueryCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct QueryCreatequeryCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct QueryCreatequeryCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a DoubleClickBidManager, + hub: &'a DoubleClickBidManager, _request: Query, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for QueryCreatequeryCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for QueryCreatequeryCall<'a, C, A> {} -impl<'a, C, NC, A> QueryCreatequeryCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> QueryCreatequeryCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2160,7 +2156,7 @@ impl<'a, C, NC, A> QueryCreatequeryCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Query) -> QueryCreatequeryCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Query) -> QueryCreatequeryCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2171,7 +2167,7 @@ impl<'a, C, NC, A> QueryCreatequeryCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> QueryCreatequeryCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> QueryCreatequeryCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2192,7 +2188,7 @@ impl<'a, C, NC, A> QueryCreatequeryCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> QueryCreatequeryCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> QueryCreatequeryCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2231,18 +2227,18 @@ impl<'a, C, NC, A> QueryCreatequeryCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct QueryDeletequeryCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct QueryDeletequeryCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a DoubleClickBidManager, + hub: &'a DoubleClickBidManager, _query_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for QueryDeletequeryCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for QueryDeletequeryCall<'a, C, A> {} -impl<'a, C, NC, A> QueryDeletequeryCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> QueryDeletequeryCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2361,7 +2357,7 @@ impl<'a, C, NC, A> QueryDeletequeryCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Query ID to delete. - pub fn query_id(mut self, new_value: &str) -> QueryDeletequeryCall<'a, C, NC, A> { + pub fn query_id(mut self, new_value: &str) -> QueryDeletequeryCall<'a, C, A> { self._query_id = new_value.to_string(); self } @@ -2372,7 +2368,7 @@ impl<'a, C, NC, A> QueryDeletequeryCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> QueryDeletequeryCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> QueryDeletequeryCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2393,7 +2389,7 @@ impl<'a, C, NC, A> QueryDeletequeryCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> QueryDeletequeryCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> QueryDeletequeryCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2438,19 +2434,19 @@ impl<'a, C, NC, A> QueryDeletequeryCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct QueryRunqueryCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct QueryRunqueryCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a DoubleClickBidManager, + hub: &'a DoubleClickBidManager, _request: RunQueryRequest, _query_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for QueryRunqueryCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for QueryRunqueryCall<'a, C, A> {} -impl<'a, C, NC, A> QueryRunqueryCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> QueryRunqueryCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2576,7 +2572,7 @@ impl<'a, C, NC, A> QueryRunqueryCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &RunQueryRequest) -> QueryRunqueryCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &RunQueryRequest) -> QueryRunqueryCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2586,7 +2582,7 @@ impl<'a, C, NC, A> QueryRunqueryCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Query ID to run. - pub fn query_id(mut self, new_value: &str) -> QueryRunqueryCall<'a, C, NC, A> { + pub fn query_id(mut self, new_value: &str) -> QueryRunqueryCall<'a, C, A> { self._query_id = new_value.to_string(); self } @@ -2597,7 +2593,7 @@ impl<'a, C, NC, A> QueryRunqueryCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> QueryRunqueryCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> QueryRunqueryCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2618,7 +2614,7 @@ impl<'a, C, NC, A> QueryRunqueryCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> QueryRunqueryCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> QueryRunqueryCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self diff --git a/gen/doubleclicksearch2/Cargo.toml b/gen/doubleclicksearch2/Cargo.toml index 52f29c28527..40b603fd107 100644 --- a/gen/doubleclicksearch2/Cargo.toml +++ b/gen/doubleclicksearch2/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-doubleclicksearch2" -version = "0.1.4+20150303" +version = "0.1.5+20150303" authors = ["Sebastian Thiel "] description = "A complete library to interact with doubleclicksearch (protocol v2)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/doubleclicksearch2" homepage = "https://developers.google.com/doubleclick-search/" -documentation = "http://byron.github.io/google-apis-rs/google-doubleclicksearch2" +documentation = "http://byron.github.io/google-apis-rs/google_doubleclicksearch2" license = "MIT" keywords = ["doubleclicksearch", "google", "protocol", "web", "api"] diff --git a/gen/doubleclicksearch2/README.md b/gen/doubleclicksearch2/README.md index 0c6eab9e290..ab62725bef1 100644 --- a/gen/doubleclicksearch2/README.md +++ b/gen/doubleclicksearch2/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-doubleclicksearch2` library allows access to all features of the *Google doubleclicksearch* service. -This documentation was generated from *doubleclicksearch* crate version *0.1.4+20150303*, where *20150303* is the exact revision of the *doubleclicksearch:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *doubleclicksearch* crate version *0.1.5+20150303*, where *20150303* is the exact revision of the *doubleclicksearch:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *doubleclicksearch* *v2* API can be found at the [official documentation site](https://developers.google.com/doubleclick-search/). diff --git a/gen/doubleclicksearch2/src/cmn.rs b/gen/doubleclicksearch2/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/doubleclicksearch2/src/cmn.rs +++ b/gen/doubleclicksearch2/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/doubleclicksearch2/src/lib.rs b/gen/doubleclicksearch2/src/lib.rs index d9c2003ce62..b5260e074ed 100644 --- a/gen/doubleclicksearch2/src/lib.rs +++ b/gen/doubleclicksearch2/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *doubleclicksearch* crate version *0.1.4+20150303*, where *20150303* is the exact revision of the *doubleclicksearch:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *doubleclicksearch* crate version *0.1.5+20150303*, where *20150303* is the exact revision of the *doubleclicksearch:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *doubleclicksearch* *v2* API can be found at the //! [official documentation site](https://developers.google.com/doubleclick-search/). @@ -199,7 +199,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -290,40 +289,37 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Doubleclicksearch { +pub struct Doubleclicksearch { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Doubleclicksearch {} +impl<'a, C, A> Hub for Doubleclicksearch {} -impl<'a, C, NC, A> Doubleclicksearch - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Doubleclicksearch + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Doubleclicksearch { + pub fn new(client: C, authenticator: A) -> Doubleclicksearch { Doubleclicksearch { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn conversion(&'a self) -> ConversionMethods<'a, C, NC, A> { + pub fn conversion(&'a self) -> ConversionMethods<'a, C, A> { ConversionMethods { hub: &self } } - pub fn reports(&'a self) -> ReportMethods<'a, C, NC, A> { + pub fn reports(&'a self) -> ReportMethods<'a, C, A> { ReportMethods { hub: &self } } - pub fn saved_columns(&'a self) -> SavedColumnMethods<'a, C, NC, A> { + pub fn saved_columns(&'a self) -> SavedColumnMethods<'a, C, A> { SavedColumnMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -875,15 +871,15 @@ impl ResponseResult for ConversionList {} /// let rb = hub.conversion(); /// # } /// ``` -pub struct ConversionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ConversionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Doubleclicksearch, + hub: &'a Doubleclicksearch, } -impl<'a, C, NC, A> MethodsBuilder for ConversionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ConversionMethods<'a, C, A> {} -impl<'a, C, NC, A> ConversionMethods<'a, C, NC, A> { +impl<'a, C, A> ConversionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -892,7 +888,7 @@ impl<'a, C, NC, A> ConversionMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &ConversionList) -> ConversionInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &ConversionList) -> ConversionInsertCall<'a, C, A> { ConversionInsertCall { hub: self.hub, _request: request.clone(), @@ -915,7 +911,7 @@ impl<'a, C, NC, A> ConversionMethods<'a, C, NC, A> { /// * `rowCount` - The number of conversions to return per call. /// * `startDate` - First date (inclusive) on which to retrieve conversions. Format is yyyymmdd. /// * `startRow` - The 0-based starting index for retrieving conversions results. - pub fn get(&self, agency_id: &str, advertiser_id: &str, engine_account_id: &str, end_date: i32, row_count: i32, start_date: i32, start_row: u32) -> ConversionGetCall<'a, C, NC, A> { + pub fn get(&self, agency_id: &str, advertiser_id: &str, engine_account_id: &str, end_date: i32, row_count: i32, start_date: i32, start_row: u32) -> ConversionGetCall<'a, C, A> { ConversionGetCall { hub: self.hub, _agency_id: agency_id.to_string(), @@ -942,7 +938,7 @@ impl<'a, C, NC, A> ConversionMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn update_availability(&self, request: &UpdateAvailabilityRequest) -> ConversionUpdateAvailabilityCall<'a, C, NC, A> { + pub fn update_availability(&self, request: &UpdateAvailabilityRequest) -> ConversionUpdateAvailabilityCall<'a, C, A> { ConversionUpdateAvailabilityCall { hub: self.hub, _request: request.clone(), @@ -966,7 +962,7 @@ impl<'a, C, NC, A> ConversionMethods<'a, C, NC, A> { /// * `rowCount` - The number of conversions to return per call. /// * `startDate` - First date (inclusive) on which to retrieve conversions. Format is yyyymmdd. /// * `startRow` - The 0-based starting index for retrieving conversions results. - pub fn patch(&self, request: &ConversionList, advertiser_id: &str, agency_id: &str, end_date: i32, engine_account_id: &str, row_count: i32, start_date: i32, start_row: u32) -> ConversionPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &ConversionList, advertiser_id: &str, agency_id: &str, end_date: i32, engine_account_id: &str, row_count: i32, start_date: i32, start_row: u32) -> ConversionPatchCall<'a, C, A> { ConversionPatchCall { hub: self.hub, _request: request.clone(), @@ -990,7 +986,7 @@ impl<'a, C, NC, A> ConversionMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn update(&self, request: &ConversionList) -> ConversionUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &ConversionList) -> ConversionUpdateCall<'a, C, A> { ConversionUpdateCall { hub: self.hub, _request: request.clone(), @@ -1031,15 +1027,15 @@ impl<'a, C, NC, A> ConversionMethods<'a, C, NC, A> { /// let rb = hub.saved_columns(); /// # } /// ``` -pub struct SavedColumnMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SavedColumnMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Doubleclicksearch, + hub: &'a Doubleclicksearch, } -impl<'a, C, NC, A> MethodsBuilder for SavedColumnMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for SavedColumnMethods<'a, C, A> {} -impl<'a, C, NC, A> SavedColumnMethods<'a, C, NC, A> { +impl<'a, C, A> SavedColumnMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1049,7 +1045,7 @@ impl<'a, C, NC, A> SavedColumnMethods<'a, C, NC, A> { /// /// * `agencyId` - DS ID of the agency. /// * `advertiserId` - DS ID of the advertiser. - pub fn list(&self, agency_id: &str, advertiser_id: &str) -> SavedColumnListCall<'a, C, NC, A> { + pub fn list(&self, agency_id: &str, advertiser_id: &str) -> SavedColumnListCall<'a, C, A> { SavedColumnListCall { hub: self.hub, _agency_id: agency_id.to_string(), @@ -1091,15 +1087,15 @@ impl<'a, C, NC, A> SavedColumnMethods<'a, C, NC, A> { /// let rb = hub.reports(); /// # } /// ``` -pub struct ReportMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Doubleclicksearch, + hub: &'a Doubleclicksearch, } -impl<'a, C, NC, A> MethodsBuilder for ReportMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ReportMethods<'a, C, A> {} -impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { +impl<'a, C, A> ReportMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1109,7 +1105,7 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// /// * `reportId` - ID of the report. /// * `reportFragment` - The index of the report fragment to download. - pub fn get_file(&self, report_id: &str, report_fragment: i32) -> ReportGetFileCall<'a, C, NC, A> { + pub fn get_file(&self, report_id: &str, report_fragment: i32) -> ReportGetFileCall<'a, C, A> { ReportGetFileCall { hub: self.hub, _report_id: report_id.to_string(), @@ -1127,7 +1123,7 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn generate(&self, request: &ReportRequest) -> ReportGenerateCall<'a, C, NC, A> { + pub fn generate(&self, request: &ReportRequest) -> ReportGenerateCall<'a, C, A> { ReportGenerateCall { hub: self.hub, _request: request.clone(), @@ -1144,7 +1140,7 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// # Arguments /// /// * `reportId` - ID of the report request being polled. - pub fn get(&self, report_id: &str) -> ReportGetCall<'a, C, NC, A> { + pub fn get(&self, report_id: &str) -> ReportGetCall<'a, C, A> { ReportGetCall { hub: self.hub, _report_id: report_id.to_string(), @@ -1161,7 +1157,7 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn request(&self, request: &ReportRequest) -> ReportRequestCall<'a, C, NC, A> { + pub fn request(&self, request: &ReportRequest) -> ReportRequestCall<'a, C, A> { ReportRequestCall { hub: self.hub, _request: request.clone(), @@ -1216,19 +1212,19 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct ConversionInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ConversionInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Doubleclicksearch, + hub: &'a Doubleclicksearch, _request: ConversionList, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ConversionInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ConversionInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ConversionInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ConversionInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1342,7 +1338,7 @@ impl<'a, C, NC, A> ConversionInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ConversionList) -> ConversionInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ConversionList) -> ConversionInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1353,7 +1349,7 @@ impl<'a, C, NC, A> ConversionInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ConversionInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ConversionInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1374,7 +1370,7 @@ impl<'a, C, NC, A> ConversionInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ConversionInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ConversionInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1391,7 +1387,7 @@ impl<'a, C, NC, A> ConversionInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ConversionInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ConversionInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1433,10 +1429,10 @@ impl<'a, C, NC, A> ConversionInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct ConversionGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ConversionGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Doubleclicksearch, + hub: &'a Doubleclicksearch, _agency_id: String, _advertiser_id: String, _engine_account_id: String, @@ -1453,9 +1449,9 @@ pub struct ConversionGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ConversionGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ConversionGetCall<'a, C, A> {} -impl<'a, C, NC, A> ConversionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ConversionGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1605,7 +1601,7 @@ impl<'a, C, NC, A> ConversionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Numeric ID of the agency. - pub fn agency_id(mut self, new_value: &str) -> ConversionGetCall<'a, C, NC, A> { + pub fn agency_id(mut self, new_value: &str) -> ConversionGetCall<'a, C, A> { self._agency_id = new_value.to_string(); self } @@ -1615,7 +1611,7 @@ impl<'a, C, NC, A> ConversionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Numeric ID of the advertiser. - pub fn advertiser_id(mut self, new_value: &str) -> ConversionGetCall<'a, C, NC, A> { + pub fn advertiser_id(mut self, new_value: &str) -> ConversionGetCall<'a, C, A> { self._advertiser_id = new_value.to_string(); self } @@ -1625,7 +1621,7 @@ impl<'a, C, NC, A> ConversionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Numeric ID of the engine account. - pub fn engine_account_id(mut self, new_value: &str) -> ConversionGetCall<'a, C, NC, A> { + pub fn engine_account_id(mut self, new_value: &str) -> ConversionGetCall<'a, C, A> { self._engine_account_id = new_value.to_string(); self } @@ -1635,7 +1631,7 @@ impl<'a, C, NC, A> ConversionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Last date (inclusive) on which to retrieve conversions. Format is yyyymmdd. - pub fn end_date(mut self, new_value: i32) -> ConversionGetCall<'a, C, NC, A> { + pub fn end_date(mut self, new_value: i32) -> ConversionGetCall<'a, C, A> { self._end_date = new_value; self } @@ -1645,7 +1641,7 @@ impl<'a, C, NC, A> ConversionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The number of conversions to return per call. - pub fn row_count(mut self, new_value: i32) -> ConversionGetCall<'a, C, NC, A> { + pub fn row_count(mut self, new_value: i32) -> ConversionGetCall<'a, C, A> { self._row_count = new_value; self } @@ -1655,7 +1651,7 @@ impl<'a, C, NC, A> ConversionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// First date (inclusive) on which to retrieve conversions. Format is yyyymmdd. - pub fn start_date(mut self, new_value: i32) -> ConversionGetCall<'a, C, NC, A> { + pub fn start_date(mut self, new_value: i32) -> ConversionGetCall<'a, C, A> { self._start_date = new_value; self } @@ -1665,7 +1661,7 @@ impl<'a, C, NC, A> ConversionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The 0-based starting index for retrieving conversions results. - pub fn start_row(mut self, new_value: u32) -> ConversionGetCall<'a, C, NC, A> { + pub fn start_row(mut self, new_value: u32) -> ConversionGetCall<'a, C, A> { self._start_row = new_value; self } @@ -1673,7 +1669,7 @@ impl<'a, C, NC, A> ConversionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Numeric ID of the criterion. - pub fn criterion_id(mut self, new_value: &str) -> ConversionGetCall<'a, C, NC, A> { + pub fn criterion_id(mut self, new_value: &str) -> ConversionGetCall<'a, C, A> { self._criterion_id = Some(new_value.to_string()); self } @@ -1681,7 +1677,7 @@ impl<'a, C, NC, A> ConversionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Numeric ID of the campaign. - pub fn campaign_id(mut self, new_value: &str) -> ConversionGetCall<'a, C, NC, A> { + pub fn campaign_id(mut self, new_value: &str) -> ConversionGetCall<'a, C, A> { self._campaign_id = Some(new_value.to_string()); self } @@ -1689,7 +1685,7 @@ impl<'a, C, NC, A> ConversionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Numeric ID of the ad. - pub fn ad_id(mut self, new_value: &str) -> ConversionGetCall<'a, C, NC, A> { + pub fn ad_id(mut self, new_value: &str) -> ConversionGetCall<'a, C, A> { self._ad_id = Some(new_value.to_string()); self } @@ -1697,7 +1693,7 @@ impl<'a, C, NC, A> ConversionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Numeric ID of the ad group. - pub fn ad_group_id(mut self, new_value: &str) -> ConversionGetCall<'a, C, NC, A> { + pub fn ad_group_id(mut self, new_value: &str) -> ConversionGetCall<'a, C, A> { self._ad_group_id = Some(new_value.to_string()); self } @@ -1708,7 +1704,7 @@ impl<'a, C, NC, A> ConversionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ConversionGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ConversionGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1729,7 +1725,7 @@ impl<'a, C, NC, A> ConversionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ConversionGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ConversionGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1746,7 +1742,7 @@ impl<'a, C, NC, A> ConversionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ConversionGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ConversionGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1790,19 +1786,19 @@ impl<'a, C, NC, A> ConversionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct ConversionUpdateAvailabilityCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ConversionUpdateAvailabilityCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Doubleclicksearch, + hub: &'a Doubleclicksearch, _request: UpdateAvailabilityRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ConversionUpdateAvailabilityCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ConversionUpdateAvailabilityCall<'a, C, A> {} -impl<'a, C, NC, A> ConversionUpdateAvailabilityCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ConversionUpdateAvailabilityCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1916,7 +1912,7 @@ impl<'a, C, NC, A> ConversionUpdateAvailabilityCall<'a, C, NC, A> where NC: hype /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &UpdateAvailabilityRequest) -> ConversionUpdateAvailabilityCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &UpdateAvailabilityRequest) -> ConversionUpdateAvailabilityCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1927,7 +1923,7 @@ impl<'a, C, NC, A> ConversionUpdateAvailabilityCall<'a, C, NC, A> where NC: hype /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ConversionUpdateAvailabilityCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ConversionUpdateAvailabilityCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1948,7 +1944,7 @@ impl<'a, C, NC, A> ConversionUpdateAvailabilityCall<'a, C, NC, A> where NC: hype /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ConversionUpdateAvailabilityCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ConversionUpdateAvailabilityCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1965,7 +1961,7 @@ impl<'a, C, NC, A> ConversionUpdateAvailabilityCall<'a, C, NC, A> where NC: hype /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ConversionUpdateAvailabilityCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ConversionUpdateAvailabilityCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2009,10 +2005,10 @@ impl<'a, C, NC, A> ConversionUpdateAvailabilityCall<'a, C, NC, A> where NC: hype /// .doit(); /// # } /// ``` -pub struct ConversionPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ConversionPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Doubleclicksearch, + hub: &'a Doubleclicksearch, _request: ConversionList, _advertiser_id: String, _agency_id: String, @@ -2026,9 +2022,9 @@ pub struct ConversionPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ConversionPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ConversionPatchCall<'a, C, A> {} -impl<'a, C, NC, A> ConversionPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ConversionPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2149,7 +2145,7 @@ impl<'a, C, NC, A> ConversionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ConversionList) -> ConversionPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ConversionList) -> ConversionPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2159,7 +2155,7 @@ impl<'a, C, NC, A> ConversionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Numeric ID of the advertiser. - pub fn advertiser_id(mut self, new_value: &str) -> ConversionPatchCall<'a, C, NC, A> { + pub fn advertiser_id(mut self, new_value: &str) -> ConversionPatchCall<'a, C, A> { self._advertiser_id = new_value.to_string(); self } @@ -2169,7 +2165,7 @@ impl<'a, C, NC, A> ConversionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Numeric ID of the agency. - pub fn agency_id(mut self, new_value: &str) -> ConversionPatchCall<'a, C, NC, A> { + pub fn agency_id(mut self, new_value: &str) -> ConversionPatchCall<'a, C, A> { self._agency_id = new_value.to_string(); self } @@ -2179,7 +2175,7 @@ impl<'a, C, NC, A> ConversionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Last date (inclusive) on which to retrieve conversions. Format is yyyymmdd. - pub fn end_date(mut self, new_value: i32) -> ConversionPatchCall<'a, C, NC, A> { + pub fn end_date(mut self, new_value: i32) -> ConversionPatchCall<'a, C, A> { self._end_date = new_value; self } @@ -2189,7 +2185,7 @@ impl<'a, C, NC, A> ConversionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Numeric ID of the engine account. - pub fn engine_account_id(mut self, new_value: &str) -> ConversionPatchCall<'a, C, NC, A> { + pub fn engine_account_id(mut self, new_value: &str) -> ConversionPatchCall<'a, C, A> { self._engine_account_id = new_value.to_string(); self } @@ -2199,7 +2195,7 @@ impl<'a, C, NC, A> ConversionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The number of conversions to return per call. - pub fn row_count(mut self, new_value: i32) -> ConversionPatchCall<'a, C, NC, A> { + pub fn row_count(mut self, new_value: i32) -> ConversionPatchCall<'a, C, A> { self._row_count = new_value; self } @@ -2209,7 +2205,7 @@ impl<'a, C, NC, A> ConversionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// First date (inclusive) on which to retrieve conversions. Format is yyyymmdd. - pub fn start_date(mut self, new_value: i32) -> ConversionPatchCall<'a, C, NC, A> { + pub fn start_date(mut self, new_value: i32) -> ConversionPatchCall<'a, C, A> { self._start_date = new_value; self } @@ -2219,7 +2215,7 @@ impl<'a, C, NC, A> ConversionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The 0-based starting index for retrieving conversions results. - pub fn start_row(mut self, new_value: u32) -> ConversionPatchCall<'a, C, NC, A> { + pub fn start_row(mut self, new_value: u32) -> ConversionPatchCall<'a, C, A> { self._start_row = new_value; self } @@ -2230,7 +2226,7 @@ impl<'a, C, NC, A> ConversionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ConversionPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ConversionPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2251,7 +2247,7 @@ impl<'a, C, NC, A> ConversionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ConversionPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ConversionPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2268,7 +2264,7 @@ impl<'a, C, NC, A> ConversionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ConversionPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ConversionPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2312,19 +2308,19 @@ impl<'a, C, NC, A> ConversionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct ConversionUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ConversionUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Doubleclicksearch, + hub: &'a Doubleclicksearch, _request: ConversionList, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ConversionUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ConversionUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ConversionUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ConversionUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2438,7 +2434,7 @@ impl<'a, C, NC, A> ConversionUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ConversionList) -> ConversionUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ConversionList) -> ConversionUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2449,7 +2445,7 @@ impl<'a, C, NC, A> ConversionUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ConversionUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ConversionUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2470,7 +2466,7 @@ impl<'a, C, NC, A> ConversionUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ConversionUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ConversionUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2487,7 +2483,7 @@ impl<'a, C, NC, A> ConversionUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ConversionUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ConversionUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2525,10 +2521,10 @@ impl<'a, C, NC, A> ConversionUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct SavedColumnListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SavedColumnListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Doubleclicksearch, + hub: &'a Doubleclicksearch, _agency_id: String, _advertiser_id: String, _delegate: Option<&'a mut Delegate>, @@ -2536,9 +2532,9 @@ pub struct SavedColumnListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SavedColumnListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SavedColumnListCall<'a, C, A> {} -impl<'a, C, NC, A> SavedColumnListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SavedColumnListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2671,7 +2667,7 @@ impl<'a, C, NC, A> SavedColumnListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// DS ID of the agency. - pub fn agency_id(mut self, new_value: &str) -> SavedColumnListCall<'a, C, NC, A> { + pub fn agency_id(mut self, new_value: &str) -> SavedColumnListCall<'a, C, A> { self._agency_id = new_value.to_string(); self } @@ -2681,7 +2677,7 @@ impl<'a, C, NC, A> SavedColumnListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// DS ID of the advertiser. - pub fn advertiser_id(mut self, new_value: &str) -> SavedColumnListCall<'a, C, NC, A> { + pub fn advertiser_id(mut self, new_value: &str) -> SavedColumnListCall<'a, C, A> { self._advertiser_id = new_value.to_string(); self } @@ -2692,7 +2688,7 @@ impl<'a, C, NC, A> SavedColumnListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SavedColumnListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SavedColumnListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2713,7 +2709,7 @@ impl<'a, C, NC, A> SavedColumnListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SavedColumnListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SavedColumnListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2730,7 +2726,7 @@ impl<'a, C, NC, A> SavedColumnListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SavedColumnListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SavedColumnListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2771,10 +2767,10 @@ impl<'a, C, NC, A> SavedColumnListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct ReportGetFileCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportGetFileCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Doubleclicksearch, + hub: &'a Doubleclicksearch, _report_id: String, _report_fragment: i32, _delegate: Option<&'a mut Delegate>, @@ -2782,9 +2778,9 @@ pub struct ReportGetFileCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReportGetFileCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReportGetFileCall<'a, C, A> {} -impl<'a, C, NC, A> ReportGetFileCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReportGetFileCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2906,7 +2902,7 @@ impl<'a, C, NC, A> ReportGetFileCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// ID of the report. - pub fn report_id(mut self, new_value: &str) -> ReportGetFileCall<'a, C, NC, A> { + pub fn report_id(mut self, new_value: &str) -> ReportGetFileCall<'a, C, A> { self._report_id = new_value.to_string(); self } @@ -2916,7 +2912,7 @@ impl<'a, C, NC, A> ReportGetFileCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The index of the report fragment to download. - pub fn report_fragment(mut self, new_value: i32) -> ReportGetFileCall<'a, C, NC, A> { + pub fn report_fragment(mut self, new_value: i32) -> ReportGetFileCall<'a, C, A> { self._report_fragment = new_value; self } @@ -2927,7 +2923,7 @@ impl<'a, C, NC, A> ReportGetFileCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportGetFileCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportGetFileCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2948,7 +2944,7 @@ impl<'a, C, NC, A> ReportGetFileCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReportGetFileCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReportGetFileCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2965,7 +2961,7 @@ impl<'a, C, NC, A> ReportGetFileCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReportGetFileCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReportGetFileCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3009,19 +3005,19 @@ impl<'a, C, NC, A> ReportGetFileCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct ReportGenerateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportGenerateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Doubleclicksearch, + hub: &'a Doubleclicksearch, _request: ReportRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReportGenerateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReportGenerateCall<'a, C, A> {} -impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReportGenerateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3135,7 +3131,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ReportRequest) -> ReportGenerateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ReportRequest) -> ReportGenerateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3146,7 +3142,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportGenerateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportGenerateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3167,7 +3163,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReportGenerateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReportGenerateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3184,7 +3180,7 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReportGenerateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReportGenerateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3222,19 +3218,19 @@ impl<'a, C, NC, A> ReportGenerateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct ReportGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Doubleclicksearch, + hub: &'a Doubleclicksearch, _report_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReportGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReportGetCall<'a, C, A> {} -impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReportGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3366,7 +3362,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// ID of the report request being polled. - pub fn report_id(mut self, new_value: &str) -> ReportGetCall<'a, C, NC, A> { + pub fn report_id(mut self, new_value: &str) -> ReportGetCall<'a, C, A> { self._report_id = new_value.to_string(); self } @@ -3377,7 +3373,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3398,7 +3394,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReportGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReportGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3415,7 +3411,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReportGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReportGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3459,19 +3455,19 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct ReportRequestCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportRequestCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Doubleclicksearch, + hub: &'a Doubleclicksearch, _request: ReportRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReportRequestCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReportRequestCall<'a, C, A> {} -impl<'a, C, NC, A> ReportRequestCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReportRequestCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3585,7 +3581,7 @@ impl<'a, C, NC, A> ReportRequestCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ReportRequest) -> ReportRequestCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ReportRequest) -> ReportRequestCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3596,7 +3592,7 @@ impl<'a, C, NC, A> ReportRequestCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportRequestCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportRequestCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3617,7 +3613,7 @@ impl<'a, C, NC, A> ReportRequestCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReportRequestCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReportRequestCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3634,7 +3630,7 @@ impl<'a, C, NC, A> ReportRequestCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReportRequestCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReportRequestCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/drive2/Cargo.toml b/gen/drive2/Cargo.toml index 5744fc8d583..cc8ec985353 100644 --- a/gen/drive2/Cargo.toml +++ b/gen/drive2/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-drive2" -version = "0.1.4+20150326" +version = "0.1.5+20150326" authors = ["Sebastian Thiel "] description = "A complete library to interact with drive (protocol v2)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/drive2" homepage = "https://developers.google.com/drive/" -documentation = "http://byron.github.io/google-apis-rs/google-drive2" +documentation = "http://byron.github.io/google-apis-rs/google_drive2" license = "MIT" keywords = ["drive", "google", "protocol", "web", "api"] diff --git a/gen/drive2/README.md b/gen/drive2/README.md index 7ecc90b34ef..27469ffeb5d 100644 --- a/gen/drive2/README.md +++ b/gen/drive2/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-drive2` library allows access to all features of the *Google drive* service. -This documentation was generated from *drive* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *drive:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *drive* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *drive:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *drive* *v2* API can be found at the [official documentation site](https://developers.google.com/drive/). diff --git a/gen/drive2/src/cmn.rs b/gen/drive2/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/drive2/src/cmn.rs +++ b/gen/drive2/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/drive2/src/lib.rs b/gen/drive2/src/lib.rs index a4cb7f5bcca..cdc18b01f2b 100644 --- a/gen/drive2/src/lib.rs +++ b/gen/drive2/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *drive* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *drive:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *drive* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *drive:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *drive* *v2* API can be found at the //! [official documentation site](https://developers.google.com/drive/). @@ -261,7 +261,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -394,70 +393,67 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Drive { +pub struct Drive { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Drive {} +impl<'a, C, A> Hub for Drive {} -impl<'a, C, NC, A> Drive - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Drive + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Drive { + pub fn new(client: C, authenticator: A) -> Drive { Drive { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn about(&'a self) -> AboutMethods<'a, C, NC, A> { + pub fn about(&'a self) -> AboutMethods<'a, C, A> { AboutMethods { hub: &self } } - pub fn apps(&'a self) -> AppMethods<'a, C, NC, A> { + pub fn apps(&'a self) -> AppMethods<'a, C, A> { AppMethods { hub: &self } } - pub fn changes(&'a self) -> ChangeMethods<'a, C, NC, A> { + pub fn changes(&'a self) -> ChangeMethods<'a, C, A> { ChangeMethods { hub: &self } } - pub fn channels(&'a self) -> ChannelMethods<'a, C, NC, A> { + pub fn channels(&'a self) -> ChannelMethods<'a, C, A> { ChannelMethods { hub: &self } } - pub fn children(&'a self) -> ChildrenMethods<'a, C, NC, A> { + pub fn children(&'a self) -> ChildrenMethods<'a, C, A> { ChildrenMethods { hub: &self } } - pub fn comments(&'a self) -> CommentMethods<'a, C, NC, A> { + pub fn comments(&'a self) -> CommentMethods<'a, C, A> { CommentMethods { hub: &self } } - pub fn files(&'a self) -> FileMethods<'a, C, NC, A> { + pub fn files(&'a self) -> FileMethods<'a, C, A> { FileMethods { hub: &self } } - pub fn parents(&'a self) -> ParentMethods<'a, C, NC, A> { + pub fn parents(&'a self) -> ParentMethods<'a, C, A> { ParentMethods { hub: &self } } - pub fn permissions(&'a self) -> PermissionMethods<'a, C, NC, A> { + pub fn permissions(&'a self) -> PermissionMethods<'a, C, A> { PermissionMethods { hub: &self } } - pub fn properties(&'a self) -> PropertyMethods<'a, C, NC, A> { + pub fn properties(&'a self) -> PropertyMethods<'a, C, A> { PropertyMethods { hub: &self } } - pub fn realtime(&'a self) -> RealtimeMethods<'a, C, NC, A> { + pub fn realtime(&'a self) -> RealtimeMethods<'a, C, A> { RealtimeMethods { hub: &self } } - pub fn replies(&'a self) -> ReplyMethods<'a, C, NC, A> { + pub fn replies(&'a self) -> ReplyMethods<'a, C, A> { ReplyMethods { hub: &self } } - pub fn revisions(&'a self) -> RevisionMethods<'a, C, NC, A> { + pub fn revisions(&'a self) -> RevisionMethods<'a, C, A> { RevisionMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -1920,15 +1916,15 @@ impl ResponseResult for Change {} /// let rb = hub.files(); /// # } /// ``` -pub struct FileMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FileMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, } -impl<'a, C, NC, A> MethodsBuilder for FileMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for FileMethods<'a, C, A> {} -impl<'a, C, NC, A> FileMethods<'a, C, NC, A> { +impl<'a, C, A> FileMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1938,7 +1934,7 @@ impl<'a, C, NC, A> FileMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `fileId` - The ID for the file in question. - pub fn watch(&self, request: &Channel, file_id: &str) -> FileWatchCall<'a, C, NC, A> { + pub fn watch(&self, request: &Channel, file_id: &str) -> FileWatchCall<'a, C, A> { FileWatchCall { hub: self.hub, _request: request.clone(), @@ -1961,7 +1957,7 @@ impl<'a, C, NC, A> FileMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &File) -> FileInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &File) -> FileInsertCall<'a, C, A> { FileInsertCall { hub: self.hub, _request: request.clone(), @@ -1986,7 +1982,7 @@ impl<'a, C, NC, A> FileMethods<'a, C, NC, A> { /// # Arguments /// /// * `fileId` - The ID of the file to untrash. - pub fn untrash(&self, file_id: &str) -> FileUntrashCall<'a, C, NC, A> { + pub fn untrash(&self, file_id: &str) -> FileUntrashCall<'a, C, A> { FileUntrashCall { hub: self.hub, _file_id: file_id.to_string(), @@ -2004,7 +2000,7 @@ impl<'a, C, NC, A> FileMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `fileId` - The ID of the file to copy. - pub fn copy(&self, request: &File, file_id: &str) -> FileCopyCall<'a, C, NC, A> { + pub fn copy(&self, request: &File, file_id: &str) -> FileCopyCall<'a, C, A> { FileCopyCall { hub: self.hub, _request: request.clone(), @@ -2029,7 +2025,7 @@ impl<'a, C, NC, A> FileMethods<'a, C, NC, A> { /// # Arguments /// /// * `fileId` - The ID of the file to trash. - pub fn trash(&self, file_id: &str) -> FileTrashCall<'a, C, NC, A> { + pub fn trash(&self, file_id: &str) -> FileTrashCall<'a, C, A> { FileTrashCall { hub: self.hub, _file_id: file_id.to_string(), @@ -2042,7 +2038,7 @@ impl<'a, C, NC, A> FileMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Permanently deletes all of the user's trashed files. - pub fn empty_trash(&self) -> FileEmptyTrashCall<'a, C, NC, A> { + pub fn empty_trash(&self) -> FileEmptyTrashCall<'a, C, A> { FileEmptyTrashCall { hub: self.hub, _delegate: Default::default(), @@ -2054,7 +2050,7 @@ impl<'a, C, NC, A> FileMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Lists the user's files. - pub fn list(&self) -> FileListCall<'a, C, NC, A> { + pub fn list(&self) -> FileListCall<'a, C, A> { FileListCall { hub: self.hub, _q: Default::default(), @@ -2075,7 +2071,7 @@ impl<'a, C, NC, A> FileMethods<'a, C, NC, A> { /// # Arguments /// /// * `fileId` - The ID of the file to update. - pub fn touch(&self, file_id: &str) -> FileTouchCall<'a, C, NC, A> { + pub fn touch(&self, file_id: &str) -> FileTouchCall<'a, C, A> { FileTouchCall { hub: self.hub, _file_id: file_id.to_string(), @@ -2093,7 +2089,7 @@ impl<'a, C, NC, A> FileMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `fileId` - The ID of the file to update. - pub fn update(&self, request: &File, file_id: &str) -> FileUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &File, file_id: &str) -> FileUpdateCall<'a, C, A> { FileUpdateCall { hub: self.hub, _request: request.clone(), @@ -2123,7 +2119,7 @@ impl<'a, C, NC, A> FileMethods<'a, C, NC, A> { /// # Arguments /// /// * `fileId` - The ID of the file to delete. - pub fn delete(&self, file_id: &str) -> FileDeleteCall<'a, C, NC, A> { + pub fn delete(&self, file_id: &str) -> FileDeleteCall<'a, C, A> { FileDeleteCall { hub: self.hub, _file_id: file_id.to_string(), @@ -2141,7 +2137,7 @@ impl<'a, C, NC, A> FileMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `fileId` - The ID of the file to update. - pub fn patch(&self, request: &File, file_id: &str) -> FilePatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &File, file_id: &str) -> FilePatchCall<'a, C, A> { FilePatchCall { hub: self.hub, _request: request.clone(), @@ -2171,7 +2167,7 @@ impl<'a, C, NC, A> FileMethods<'a, C, NC, A> { /// # Arguments /// /// * `fileId` - The ID for the file in question. - pub fn get(&self, file_id: &str) -> FileGetCall<'a, C, NC, A> { + pub fn get(&self, file_id: &str) -> FileGetCall<'a, C, A> { FileGetCall { hub: self.hub, _file_id: file_id.to_string(), @@ -2217,20 +2213,20 @@ impl<'a, C, NC, A> FileMethods<'a, C, NC, A> { /// let rb = hub.about(); /// # } /// ``` -pub struct AboutMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AboutMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, } -impl<'a, C, NC, A> MethodsBuilder for AboutMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AboutMethods<'a, C, A> {} -impl<'a, C, NC, A> AboutMethods<'a, C, NC, A> { +impl<'a, C, A> AboutMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Gets the information about the current user along with Drive API settings - pub fn get(&self) -> AboutGetCall<'a, C, NC, A> { + pub fn get(&self) -> AboutGetCall<'a, C, A> { AboutGetCall { hub: self.hub, _start_change_id: Default::default(), @@ -2273,15 +2269,15 @@ impl<'a, C, NC, A> AboutMethods<'a, C, NC, A> { /// let rb = hub.realtime(); /// # } /// ``` -pub struct RealtimeMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RealtimeMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, } -impl<'a, C, NC, A> MethodsBuilder for RealtimeMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for RealtimeMethods<'a, C, A> {} -impl<'a, C, NC, A> RealtimeMethods<'a, C, NC, A> { +impl<'a, C, A> RealtimeMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2290,7 +2286,7 @@ impl<'a, C, NC, A> RealtimeMethods<'a, C, NC, A> { /// # Arguments /// /// * `fileId` - The ID of the file that the Realtime API data model is associated with. - pub fn update(&self, file_id: &str) -> RealtimeUpdateCall<'a, C, NC, A> { + pub fn update(&self, file_id: &str) -> RealtimeUpdateCall<'a, C, A> { RealtimeUpdateCall { hub: self.hub, _file_id: file_id.to_string(), @@ -2308,7 +2304,7 @@ impl<'a, C, NC, A> RealtimeMethods<'a, C, NC, A> { /// # Arguments /// /// * `fileId` - The ID of the file that the Realtime API data model is associated with. - pub fn get(&self, file_id: &str) -> RealtimeGetCall<'a, C, NC, A> { + pub fn get(&self, file_id: &str) -> RealtimeGetCall<'a, C, A> { RealtimeGetCall { hub: self.hub, _file_id: file_id.to_string(), @@ -2350,15 +2346,15 @@ impl<'a, C, NC, A> RealtimeMethods<'a, C, NC, A> { /// let rb = hub.apps(); /// # } /// ``` -pub struct AppMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AppMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, } -impl<'a, C, NC, A> MethodsBuilder for AppMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AppMethods<'a, C, A> {} -impl<'a, C, NC, A> AppMethods<'a, C, NC, A> { +impl<'a, C, A> AppMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2367,7 +2363,7 @@ impl<'a, C, NC, A> AppMethods<'a, C, NC, A> { /// # Arguments /// /// * `appId` - The ID of the app. - pub fn get(&self, app_id: &str) -> AppGetCall<'a, C, NC, A> { + pub fn get(&self, app_id: &str) -> AppGetCall<'a, C, A> { AppGetCall { hub: self.hub, _app_id: app_id.to_string(), @@ -2380,7 +2376,7 @@ impl<'a, C, NC, A> AppMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Lists a user's installed apps. - pub fn list(&self) -> AppListCall<'a, C, NC, A> { + pub fn list(&self) -> AppListCall<'a, C, A> { AppListCall { hub: self.hub, _language_code: Default::default(), @@ -2423,15 +2419,15 @@ impl<'a, C, NC, A> AppMethods<'a, C, NC, A> { /// let rb = hub.comments(); /// # } /// ``` -pub struct CommentMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CommentMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, } -impl<'a, C, NC, A> MethodsBuilder for CommentMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CommentMethods<'a, C, A> {} -impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { +impl<'a, C, A> CommentMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2441,7 +2437,7 @@ impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { /// /// * `fileId` - The ID of the file. /// * `commentId` - The ID of the comment. - pub fn delete(&self, file_id: &str, comment_id: &str) -> CommentDeleteCall<'a, C, NC, A> { + pub fn delete(&self, file_id: &str, comment_id: &str) -> CommentDeleteCall<'a, C, A> { CommentDeleteCall { hub: self.hub, _file_id: file_id.to_string(), @@ -2460,7 +2456,7 @@ impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { /// /// * `fileId` - The ID of the file. /// * `commentId` - The ID of the comment. - pub fn get(&self, file_id: &str, comment_id: &str) -> CommentGetCall<'a, C, NC, A> { + pub fn get(&self, file_id: &str, comment_id: &str) -> CommentGetCall<'a, C, A> { CommentGetCall { hub: self.hub, _file_id: file_id.to_string(), @@ -2480,7 +2476,7 @@ impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `fileId` - The ID of the file. - pub fn insert(&self, request: &Comment, file_id: &str) -> CommentInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Comment, file_id: &str) -> CommentInsertCall<'a, C, A> { CommentInsertCall { hub: self.hub, _request: request.clone(), @@ -2500,7 +2496,7 @@ impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `fileId` - The ID of the file. /// * `commentId` - The ID of the comment. - pub fn patch(&self, request: &Comment, file_id: &str, comment_id: &str) -> CommentPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Comment, file_id: &str, comment_id: &str) -> CommentPatchCall<'a, C, A> { CommentPatchCall { hub: self.hub, _request: request.clone(), @@ -2521,7 +2517,7 @@ impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `fileId` - The ID of the file. /// * `commentId` - The ID of the comment. - pub fn update(&self, request: &Comment, file_id: &str, comment_id: &str) -> CommentUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Comment, file_id: &str, comment_id: &str) -> CommentUpdateCall<'a, C, A> { CommentUpdateCall { hub: self.hub, _request: request.clone(), @@ -2540,7 +2536,7 @@ impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { /// # Arguments /// /// * `fileId` - The ID of the file. - pub fn list(&self, file_id: &str) -> CommentListCall<'a, C, NC, A> { + pub fn list(&self, file_id: &str) -> CommentListCall<'a, C, A> { CommentListCall { hub: self.hub, _file_id: file_id.to_string(), @@ -2585,15 +2581,15 @@ impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { /// let rb = hub.children(); /// # } /// ``` -pub struct ChildrenMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChildrenMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, } -impl<'a, C, NC, A> MethodsBuilder for ChildrenMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ChildrenMethods<'a, C, A> {} -impl<'a, C, NC, A> ChildrenMethods<'a, C, NC, A> { +impl<'a, C, A> ChildrenMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2602,7 +2598,7 @@ impl<'a, C, NC, A> ChildrenMethods<'a, C, NC, A> { /// # Arguments /// /// * `folderId` - The ID of the folder. - pub fn list(&self, folder_id: &str) -> ChildrenListCall<'a, C, NC, A> { + pub fn list(&self, folder_id: &str) -> ChildrenListCall<'a, C, A> { ChildrenListCall { hub: self.hub, _folder_id: folder_id.to_string(), @@ -2623,7 +2619,7 @@ impl<'a, C, NC, A> ChildrenMethods<'a, C, NC, A> { /// /// * `folderId` - The ID of the folder. /// * `childId` - The ID of the child. - pub fn get(&self, folder_id: &str, child_id: &str) -> ChildrenGetCall<'a, C, NC, A> { + pub fn get(&self, folder_id: &str, child_id: &str) -> ChildrenGetCall<'a, C, A> { ChildrenGetCall { hub: self.hub, _folder_id: folder_id.to_string(), @@ -2642,7 +2638,7 @@ impl<'a, C, NC, A> ChildrenMethods<'a, C, NC, A> { /// /// * `folderId` - The ID of the folder. /// * `childId` - The ID of the child. - pub fn delete(&self, folder_id: &str, child_id: &str) -> ChildrenDeleteCall<'a, C, NC, A> { + pub fn delete(&self, folder_id: &str, child_id: &str) -> ChildrenDeleteCall<'a, C, A> { ChildrenDeleteCall { hub: self.hub, _folder_id: folder_id.to_string(), @@ -2661,7 +2657,7 @@ impl<'a, C, NC, A> ChildrenMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `folderId` - The ID of the folder. - pub fn insert(&self, request: &ChildReference, folder_id: &str) -> ChildrenInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &ChildReference, folder_id: &str) -> ChildrenInsertCall<'a, C, A> { ChildrenInsertCall { hub: self.hub, _request: request.clone(), @@ -2703,15 +2699,15 @@ impl<'a, C, NC, A> ChildrenMethods<'a, C, NC, A> { /// let rb = hub.channels(); /// # } /// ``` -pub struct ChannelMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChannelMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, } -impl<'a, C, NC, A> MethodsBuilder for ChannelMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ChannelMethods<'a, C, A> {} -impl<'a, C, NC, A> ChannelMethods<'a, C, NC, A> { +impl<'a, C, A> ChannelMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2720,7 +2716,7 @@ impl<'a, C, NC, A> ChannelMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn stop(&self, request: &Channel) -> ChannelStopCall<'a, C, NC, A> { + pub fn stop(&self, request: &Channel) -> ChannelStopCall<'a, C, A> { ChannelStopCall { hub: self.hub, _request: request.clone(), @@ -2761,15 +2757,15 @@ impl<'a, C, NC, A> ChannelMethods<'a, C, NC, A> { /// let rb = hub.parents(); /// # } /// ``` -pub struct ParentMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ParentMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, } -impl<'a, C, NC, A> MethodsBuilder for ParentMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ParentMethods<'a, C, A> {} -impl<'a, C, NC, A> ParentMethods<'a, C, NC, A> { +impl<'a, C, A> ParentMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2778,7 +2774,7 @@ impl<'a, C, NC, A> ParentMethods<'a, C, NC, A> { /// # Arguments /// /// * `fileId` - The ID of the file. - pub fn list(&self, file_id: &str) -> ParentListCall<'a, C, NC, A> { + pub fn list(&self, file_id: &str) -> ParentListCall<'a, C, A> { ParentListCall { hub: self.hub, _file_id: file_id.to_string(), @@ -2796,7 +2792,7 @@ impl<'a, C, NC, A> ParentMethods<'a, C, NC, A> { /// /// * `fileId` - The ID of the file. /// * `parentId` - The ID of the parent. - pub fn delete(&self, file_id: &str, parent_id: &str) -> ParentDeleteCall<'a, C, NC, A> { + pub fn delete(&self, file_id: &str, parent_id: &str) -> ParentDeleteCall<'a, C, A> { ParentDeleteCall { hub: self.hub, _file_id: file_id.to_string(), @@ -2815,7 +2811,7 @@ impl<'a, C, NC, A> ParentMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `fileId` - The ID of the file. - pub fn insert(&self, request: &ParentReference, file_id: &str) -> ParentInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &ParentReference, file_id: &str) -> ParentInsertCall<'a, C, A> { ParentInsertCall { hub: self.hub, _request: request.clone(), @@ -2834,7 +2830,7 @@ impl<'a, C, NC, A> ParentMethods<'a, C, NC, A> { /// /// * `fileId` - The ID of the file. /// * `parentId` - The ID of the parent. - pub fn get(&self, file_id: &str, parent_id: &str) -> ParentGetCall<'a, C, NC, A> { + pub fn get(&self, file_id: &str, parent_id: &str) -> ParentGetCall<'a, C, A> { ParentGetCall { hub: self.hub, _file_id: file_id.to_string(), @@ -2876,15 +2872,15 @@ impl<'a, C, NC, A> ParentMethods<'a, C, NC, A> { /// let rb = hub.replies(); /// # } /// ``` -pub struct ReplyMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReplyMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, } -impl<'a, C, NC, A> MethodsBuilder for ReplyMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ReplyMethods<'a, C, A> {} -impl<'a, C, NC, A> ReplyMethods<'a, C, NC, A> { +impl<'a, C, A> ReplyMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2896,7 +2892,7 @@ impl<'a, C, NC, A> ReplyMethods<'a, C, NC, A> { /// * `fileId` - The ID of the file. /// * `commentId` - The ID of the comment. /// * `replyId` - The ID of the reply. - pub fn patch(&self, request: &CommentReply, file_id: &str, comment_id: &str, reply_id: &str) -> ReplyPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &CommentReply, file_id: &str, comment_id: &str, reply_id: &str) -> ReplyPatchCall<'a, C, A> { ReplyPatchCall { hub: self.hub, _request: request.clone(), @@ -2917,7 +2913,7 @@ impl<'a, C, NC, A> ReplyMethods<'a, C, NC, A> { /// /// * `fileId` - The ID of the file. /// * `commentId` - The ID of the comment. - pub fn list(&self, file_id: &str, comment_id: &str) -> ReplyListCall<'a, C, NC, A> { + pub fn list(&self, file_id: &str, comment_id: &str) -> ReplyListCall<'a, C, A> { ReplyListCall { hub: self.hub, _file_id: file_id.to_string(), @@ -2940,7 +2936,7 @@ impl<'a, C, NC, A> ReplyMethods<'a, C, NC, A> { /// * `fileId` - The ID of the file. /// * `commentId` - The ID of the comment. /// * `replyId` - The ID of the reply. - pub fn get(&self, file_id: &str, comment_id: &str, reply_id: &str) -> ReplyGetCall<'a, C, NC, A> { + pub fn get(&self, file_id: &str, comment_id: &str, reply_id: &str) -> ReplyGetCall<'a, C, A> { ReplyGetCall { hub: self.hub, _file_id: file_id.to_string(), @@ -2962,7 +2958,7 @@ impl<'a, C, NC, A> ReplyMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `fileId` - The ID of the file. /// * `commentId` - The ID of the comment. - pub fn insert(&self, request: &CommentReply, file_id: &str, comment_id: &str) -> ReplyInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &CommentReply, file_id: &str, comment_id: &str) -> ReplyInsertCall<'a, C, A> { ReplyInsertCall { hub: self.hub, _request: request.clone(), @@ -2983,7 +2979,7 @@ impl<'a, C, NC, A> ReplyMethods<'a, C, NC, A> { /// * `fileId` - The ID of the file. /// * `commentId` - The ID of the comment. /// * `replyId` - The ID of the reply. - pub fn delete(&self, file_id: &str, comment_id: &str, reply_id: &str) -> ReplyDeleteCall<'a, C, NC, A> { + pub fn delete(&self, file_id: &str, comment_id: &str, reply_id: &str) -> ReplyDeleteCall<'a, C, A> { ReplyDeleteCall { hub: self.hub, _file_id: file_id.to_string(), @@ -3005,7 +3001,7 @@ impl<'a, C, NC, A> ReplyMethods<'a, C, NC, A> { /// * `fileId` - The ID of the file. /// * `commentId` - The ID of the comment. /// * `replyId` - The ID of the reply. - pub fn update(&self, request: &CommentReply, file_id: &str, comment_id: &str, reply_id: &str) -> ReplyUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &CommentReply, file_id: &str, comment_id: &str, reply_id: &str) -> ReplyUpdateCall<'a, C, A> { ReplyUpdateCall { hub: self.hub, _request: request.clone(), @@ -3049,15 +3045,15 @@ impl<'a, C, NC, A> ReplyMethods<'a, C, NC, A> { /// let rb = hub.permissions(); /// # } /// ``` -pub struct PermissionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PermissionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, } -impl<'a, C, NC, A> MethodsBuilder for PermissionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PermissionMethods<'a, C, A> {} -impl<'a, C, NC, A> PermissionMethods<'a, C, NC, A> { +impl<'a, C, A> PermissionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3067,7 +3063,7 @@ impl<'a, C, NC, A> PermissionMethods<'a, C, NC, A> { /// /// * `fileId` - The ID for the file. /// * `permissionId` - The ID for the permission. - pub fn delete(&self, file_id: &str, permission_id: &str) -> PermissionDeleteCall<'a, C, NC, A> { + pub fn delete(&self, file_id: &str, permission_id: &str) -> PermissionDeleteCall<'a, C, A> { PermissionDeleteCall { hub: self.hub, _file_id: file_id.to_string(), @@ -3086,7 +3082,7 @@ impl<'a, C, NC, A> PermissionMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `fileId` - The ID for the file. - pub fn insert(&self, request: &Permission, file_id: &str) -> PermissionInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Permission, file_id: &str) -> PermissionInsertCall<'a, C, A> { PermissionInsertCall { hub: self.hub, _request: request.clone(), @@ -3108,7 +3104,7 @@ impl<'a, C, NC, A> PermissionMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `fileId` - The ID for the file. /// * `permissionId` - The ID for the permission. - pub fn update(&self, request: &Permission, file_id: &str, permission_id: &str) -> PermissionUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Permission, file_id: &str, permission_id: &str) -> PermissionUpdateCall<'a, C, A> { PermissionUpdateCall { hub: self.hub, _request: request.clone(), @@ -3130,7 +3126,7 @@ impl<'a, C, NC, A> PermissionMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `fileId` - The ID for the file. /// * `permissionId` - The ID for the permission. - pub fn patch(&self, request: &Permission, file_id: &str, permission_id: &str) -> PermissionPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Permission, file_id: &str, permission_id: &str) -> PermissionPatchCall<'a, C, A> { PermissionPatchCall { hub: self.hub, _request: request.clone(), @@ -3150,7 +3146,7 @@ impl<'a, C, NC, A> PermissionMethods<'a, C, NC, A> { /// # Arguments /// /// * `fileId` - The ID for the file. - pub fn list(&self, file_id: &str) -> PermissionListCall<'a, C, NC, A> { + pub fn list(&self, file_id: &str) -> PermissionListCall<'a, C, A> { PermissionListCall { hub: self.hub, _file_id: file_id.to_string(), @@ -3168,7 +3164,7 @@ impl<'a, C, NC, A> PermissionMethods<'a, C, NC, A> { /// /// * `fileId` - The ID for the file. /// * `permissionId` - The ID for the permission. - pub fn get(&self, file_id: &str, permission_id: &str) -> PermissionGetCall<'a, C, NC, A> { + pub fn get(&self, file_id: &str, permission_id: &str) -> PermissionGetCall<'a, C, A> { PermissionGetCall { hub: self.hub, _file_id: file_id.to_string(), @@ -3186,7 +3182,7 @@ impl<'a, C, NC, A> PermissionMethods<'a, C, NC, A> { /// # Arguments /// /// * `email` - The email address for which to return a permission ID - pub fn get_id_for_email(&self, email: &str) -> PermissionGetIdForEmailCall<'a, C, NC, A> { + pub fn get_id_for_email(&self, email: &str) -> PermissionGetIdForEmailCall<'a, C, A> { PermissionGetIdForEmailCall { hub: self.hub, _email: email.to_string(), @@ -3227,15 +3223,15 @@ impl<'a, C, NC, A> PermissionMethods<'a, C, NC, A> { /// let rb = hub.changes(); /// # } /// ``` -pub struct ChangeMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChangeMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, } -impl<'a, C, NC, A> MethodsBuilder for ChangeMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ChangeMethods<'a, C, A> {} -impl<'a, C, NC, A> ChangeMethods<'a, C, NC, A> { +impl<'a, C, A> ChangeMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3244,7 +3240,7 @@ impl<'a, C, NC, A> ChangeMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn watch(&self, request: &Channel) -> ChangeWatchCall<'a, C, NC, A> { + pub fn watch(&self, request: &Channel) -> ChangeWatchCall<'a, C, A> { ChangeWatchCall { hub: self.hub, _request: request.clone(), @@ -3262,7 +3258,7 @@ impl<'a, C, NC, A> ChangeMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Lists the changes for a user. - pub fn list(&self) -> ChangeListCall<'a, C, NC, A> { + pub fn list(&self) -> ChangeListCall<'a, C, A> { ChangeListCall { hub: self.hub, _start_change_id: Default::default(), @@ -3283,7 +3279,7 @@ impl<'a, C, NC, A> ChangeMethods<'a, C, NC, A> { /// # Arguments /// /// * `changeId` - The ID of the change. - pub fn get(&self, change_id: &str) -> ChangeGetCall<'a, C, NC, A> { + pub fn get(&self, change_id: &str) -> ChangeGetCall<'a, C, A> { ChangeGetCall { hub: self.hub, _change_id: change_id.to_string(), @@ -3324,15 +3320,15 @@ impl<'a, C, NC, A> ChangeMethods<'a, C, NC, A> { /// let rb = hub.properties(); /// # } /// ``` -pub struct PropertyMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PropertyMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, } -impl<'a, C, NC, A> MethodsBuilder for PropertyMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PropertyMethods<'a, C, A> {} -impl<'a, C, NC, A> PropertyMethods<'a, C, NC, A> { +impl<'a, C, A> PropertyMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3343,7 +3339,7 @@ impl<'a, C, NC, A> PropertyMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `fileId` - The ID of the file. /// * `propertyKey` - The key of the property. - pub fn patch(&self, request: &Property, file_id: &str, property_key: &str) -> PropertyPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Property, file_id: &str, property_key: &str) -> PropertyPatchCall<'a, C, A> { PropertyPatchCall { hub: self.hub, _request: request.clone(), @@ -3364,7 +3360,7 @@ impl<'a, C, NC, A> PropertyMethods<'a, C, NC, A> { /// /// * `fileId` - The ID of the file. /// * `propertyKey` - The key of the property. - pub fn delete(&self, file_id: &str, property_key: &str) -> PropertyDeleteCall<'a, C, NC, A> { + pub fn delete(&self, file_id: &str, property_key: &str) -> PropertyDeleteCall<'a, C, A> { PropertyDeleteCall { hub: self.hub, _file_id: file_id.to_string(), @@ -3384,7 +3380,7 @@ impl<'a, C, NC, A> PropertyMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `fileId` - The ID of the file. - pub fn insert(&self, request: &Property, file_id: &str) -> PropertyInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Property, file_id: &str) -> PropertyInsertCall<'a, C, A> { PropertyInsertCall { hub: self.hub, _request: request.clone(), @@ -3402,7 +3398,7 @@ impl<'a, C, NC, A> PropertyMethods<'a, C, NC, A> { /// # Arguments /// /// * `fileId` - The ID of the file. - pub fn list(&self, file_id: &str) -> PropertyListCall<'a, C, NC, A> { + pub fn list(&self, file_id: &str) -> PropertyListCall<'a, C, A> { PropertyListCall { hub: self.hub, _file_id: file_id.to_string(), @@ -3421,7 +3417,7 @@ impl<'a, C, NC, A> PropertyMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `fileId` - The ID of the file. /// * `propertyKey` - The key of the property. - pub fn update(&self, request: &Property, file_id: &str, property_key: &str) -> PropertyUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Property, file_id: &str, property_key: &str) -> PropertyUpdateCall<'a, C, A> { PropertyUpdateCall { hub: self.hub, _request: request.clone(), @@ -3442,7 +3438,7 @@ impl<'a, C, NC, A> PropertyMethods<'a, C, NC, A> { /// /// * `fileId` - The ID of the file. /// * `propertyKey` - The key of the property. - pub fn get(&self, file_id: &str, property_key: &str) -> PropertyGetCall<'a, C, NC, A> { + pub fn get(&self, file_id: &str, property_key: &str) -> PropertyGetCall<'a, C, A> { PropertyGetCall { hub: self.hub, _file_id: file_id.to_string(), @@ -3485,15 +3481,15 @@ impl<'a, C, NC, A> PropertyMethods<'a, C, NC, A> { /// let rb = hub.revisions(); /// # } /// ``` -pub struct RevisionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RevisionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, } -impl<'a, C, NC, A> MethodsBuilder for RevisionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for RevisionMethods<'a, C, A> {} -impl<'a, C, NC, A> RevisionMethods<'a, C, NC, A> { +impl<'a, C, A> RevisionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3503,7 +3499,7 @@ impl<'a, C, NC, A> RevisionMethods<'a, C, NC, A> { /// /// * `fileId` - The ID of the file. /// * `revisionId` - The ID of the revision. - pub fn get(&self, file_id: &str, revision_id: &str) -> RevisionGetCall<'a, C, NC, A> { + pub fn get(&self, file_id: &str, revision_id: &str) -> RevisionGetCall<'a, C, A> { RevisionGetCall { hub: self.hub, _file_id: file_id.to_string(), @@ -3522,7 +3518,7 @@ impl<'a, C, NC, A> RevisionMethods<'a, C, NC, A> { /// /// * `fileId` - The ID of the file. /// * `revisionId` - The ID of the revision. - pub fn delete(&self, file_id: &str, revision_id: &str) -> RevisionDeleteCall<'a, C, NC, A> { + pub fn delete(&self, file_id: &str, revision_id: &str) -> RevisionDeleteCall<'a, C, A> { RevisionDeleteCall { hub: self.hub, _file_id: file_id.to_string(), @@ -3542,7 +3538,7 @@ impl<'a, C, NC, A> RevisionMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `fileId` - The ID for the file. /// * `revisionId` - The ID for the revision. - pub fn update(&self, request: &Revision, file_id: &str, revision_id: &str) -> RevisionUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Revision, file_id: &str, revision_id: &str) -> RevisionUpdateCall<'a, C, A> { RevisionUpdateCall { hub: self.hub, _request: request.clone(), @@ -3561,7 +3557,7 @@ impl<'a, C, NC, A> RevisionMethods<'a, C, NC, A> { /// # Arguments /// /// * `fileId` - The ID of the file. - pub fn list(&self, file_id: &str) -> RevisionListCall<'a, C, NC, A> { + pub fn list(&self, file_id: &str) -> RevisionListCall<'a, C, A> { RevisionListCall { hub: self.hub, _file_id: file_id.to_string(), @@ -3580,7 +3576,7 @@ impl<'a, C, NC, A> RevisionMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `fileId` - The ID for the file. /// * `revisionId` - The ID for the revision. - pub fn patch(&self, request: &Revision, file_id: &str, revision_id: &str) -> RevisionPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Revision, file_id: &str, revision_id: &str) -> RevisionPatchCall<'a, C, A> { RevisionPatchCall { hub: self.hub, _request: request.clone(), @@ -3647,10 +3643,10 @@ impl<'a, C, NC, A> RevisionMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct FileWatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FileWatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _request: Channel, _file_id: String, _update_viewed_date: Option, @@ -3663,9 +3659,9 @@ pub struct FileWatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FileWatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FileWatchCall<'a, C, A> {} -impl<'a, C, NC, A> FileWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FileWatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3835,7 +3831,7 @@ impl<'a, C, NC, A> FileWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Channel) -> FileWatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Channel) -> FileWatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3845,7 +3841,7 @@ impl<'a, C, NC, A> FileWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID for the file in question. - pub fn file_id(mut self, new_value: &str) -> FileWatchCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> FileWatchCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -3853,7 +3849,7 @@ impl<'a, C, NC, A> FileWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether to update the view date after successfully retrieving the file. - pub fn update_viewed_date(mut self, new_value: bool) -> FileWatchCall<'a, C, NC, A> { + pub fn update_viewed_date(mut self, new_value: bool) -> FileWatchCall<'a, C, A> { self._update_viewed_date = Some(new_value); self } @@ -3861,7 +3857,7 @@ impl<'a, C, NC, A> FileWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Specifies the Revision ID that should be downloaded. Ignored unless alt=media is specified. - pub fn revision_id(mut self, new_value: &str) -> FileWatchCall<'a, C, NC, A> { + pub fn revision_id(mut self, new_value: &str) -> FileWatchCall<'a, C, A> { self._revision_id = Some(new_value.to_string()); self } @@ -3869,7 +3865,7 @@ impl<'a, C, NC, A> FileWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// This parameter is deprecated and has no function. - pub fn projection(mut self, new_value: &str) -> FileWatchCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> FileWatchCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -3877,7 +3873,7 @@ impl<'a, C, NC, A> FileWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Specifies the type of resource representation to return. The default is 'json' to return file metadata. Specifying 'media' will cause the file content to be returned. - pub fn alt(mut self, new_value: &str) -> FileWatchCall<'a, C, NC, A> { + pub fn alt(mut self, new_value: &str) -> FileWatchCall<'a, C, A> { self._alt = Some(new_value.to_string()); self } @@ -3885,7 +3881,7 @@ impl<'a, C, NC, A> FileWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether the user is acknowledging the risk of downloading known malware or other abusive files. Ignored unless alt=media is specified. - pub fn acknowledge_abuse(mut self, new_value: bool) -> FileWatchCall<'a, C, NC, A> { + pub fn acknowledge_abuse(mut self, new_value: bool) -> FileWatchCall<'a, C, A> { self._acknowledge_abuse = Some(new_value); self } @@ -3896,7 +3892,7 @@ impl<'a, C, NC, A> FileWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileWatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileWatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3917,7 +3913,7 @@ impl<'a, C, NC, A> FileWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FileWatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FileWatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3934,7 +3930,7 @@ impl<'a, C, NC, A> FileWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FileWatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FileWatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3987,10 +3983,10 @@ impl<'a, C, NC, A> FileWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .upload_resumable(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct FileInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FileInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _request: File, _visibility: Option, _use_content_as_indexable_text: Option, @@ -4005,9 +4001,9 @@ pub struct FileInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FileInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FileInsertCall<'a, C, A> {} -impl<'a, C, NC, A> FileInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FileInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4259,7 +4255,7 @@ impl<'a, C, NC, A> FileInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &File) -> FileInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &File) -> FileInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4267,7 +4263,7 @@ impl<'a, C, NC, A> FileInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The visibility of the new file. This parameter is only relevant when convert=false. - pub fn visibility(mut self, new_value: &str) -> FileInsertCall<'a, C, NC, A> { + pub fn visibility(mut self, new_value: &str) -> FileInsertCall<'a, C, A> { self._visibility = Some(new_value.to_string()); self } @@ -4275,7 +4271,7 @@ impl<'a, C, NC, A> FileInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether to use the content as indexable text. - pub fn use_content_as_indexable_text(mut self, new_value: bool) -> FileInsertCall<'a, C, NC, A> { + pub fn use_content_as_indexable_text(mut self, new_value: bool) -> FileInsertCall<'a, C, A> { self._use_content_as_indexable_text = Some(new_value); self } @@ -4283,7 +4279,7 @@ impl<'a, C, NC, A> FileInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The timed text track name. - pub fn timed_text_track_name(mut self, new_value: &str) -> FileInsertCall<'a, C, NC, A> { + pub fn timed_text_track_name(mut self, new_value: &str) -> FileInsertCall<'a, C, A> { self._timed_text_track_name = Some(new_value.to_string()); self } @@ -4291,7 +4287,7 @@ impl<'a, C, NC, A> FileInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The language of the timed text. - pub fn timed_text_language(mut self, new_value: &str) -> FileInsertCall<'a, C, NC, A> { + pub fn timed_text_language(mut self, new_value: &str) -> FileInsertCall<'a, C, A> { self._timed_text_language = Some(new_value.to_string()); self } @@ -4299,7 +4295,7 @@ impl<'a, C, NC, A> FileInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether to pin the head revision of the uploaded file. A file can have a maximum of 200 pinned revisions. - pub fn pinned(mut self, new_value: bool) -> FileInsertCall<'a, C, NC, A> { + pub fn pinned(mut self, new_value: bool) -> FileInsertCall<'a, C, A> { self._pinned = Some(new_value); self } @@ -4307,7 +4303,7 @@ impl<'a, C, NC, A> FileInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// If ocr is true, hints at the language to use. Valid values are ISO 639-1 codes. - pub fn ocr_language(mut self, new_value: &str) -> FileInsertCall<'a, C, NC, A> { + pub fn ocr_language(mut self, new_value: &str) -> FileInsertCall<'a, C, A> { self._ocr_language = Some(new_value.to_string()); self } @@ -4315,7 +4311,7 @@ impl<'a, C, NC, A> FileInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether to attempt OCR on .jpg, .png, .gif, or .pdf uploads. - pub fn ocr(mut self, new_value: bool) -> FileInsertCall<'a, C, NC, A> { + pub fn ocr(mut self, new_value: bool) -> FileInsertCall<'a, C, A> { self._ocr = Some(new_value); self } @@ -4323,7 +4319,7 @@ impl<'a, C, NC, A> FileInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether to convert this file to the corresponding Google Docs format. - pub fn convert(mut self, new_value: bool) -> FileInsertCall<'a, C, NC, A> { + pub fn convert(mut self, new_value: bool) -> FileInsertCall<'a, C, A> { self._convert = Some(new_value); self } @@ -4334,7 +4330,7 @@ impl<'a, C, NC, A> FileInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4355,7 +4351,7 @@ impl<'a, C, NC, A> FileInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FileInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FileInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4372,7 +4368,7 @@ impl<'a, C, NC, A> FileInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FileInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FileInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4410,19 +4406,19 @@ impl<'a, C, NC, A> FileInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct FileUntrashCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FileUntrashCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FileUntrashCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FileUntrashCall<'a, C, A> {} -impl<'a, C, NC, A> FileUntrashCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FileUntrashCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4554,7 +4550,7 @@ impl<'a, C, NC, A> FileUntrashCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the file to untrash. - pub fn file_id(mut self, new_value: &str) -> FileUntrashCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> FileUntrashCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -4565,7 +4561,7 @@ impl<'a, C, NC, A> FileUntrashCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileUntrashCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileUntrashCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4586,7 +4582,7 @@ impl<'a, C, NC, A> FileUntrashCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FileUntrashCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FileUntrashCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4603,7 +4599,7 @@ impl<'a, C, NC, A> FileUntrashCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FileUntrashCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FileUntrashCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4654,10 +4650,10 @@ impl<'a, C, NC, A> FileUntrashCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct FileCopyCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FileCopyCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _request: File, _file_id: String, _visibility: Option, @@ -4672,9 +4668,9 @@ pub struct FileCopyCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FileCopyCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FileCopyCall<'a, C, A> {} -impl<'a, C, NC, A> FileCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FileCopyCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4834,7 +4830,7 @@ impl<'a, C, NC, A> FileCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &File) -> FileCopyCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &File) -> FileCopyCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4844,7 +4840,7 @@ impl<'a, C, NC, A> FileCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The ID of the file to copy. - pub fn file_id(mut self, new_value: &str) -> FileCopyCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> FileCopyCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -4852,7 +4848,7 @@ impl<'a, C, NC, A> FileCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The visibility of the new file. This parameter is only relevant when the source is not a native Google Doc and convert=false. - pub fn visibility(mut self, new_value: &str) -> FileCopyCall<'a, C, NC, A> { + pub fn visibility(mut self, new_value: &str) -> FileCopyCall<'a, C, A> { self._visibility = Some(new_value.to_string()); self } @@ -4860,7 +4856,7 @@ impl<'a, C, NC, A> FileCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The timed text track name. - pub fn timed_text_track_name(mut self, new_value: &str) -> FileCopyCall<'a, C, NC, A> { + pub fn timed_text_track_name(mut self, new_value: &str) -> FileCopyCall<'a, C, A> { self._timed_text_track_name = Some(new_value.to_string()); self } @@ -4868,7 +4864,7 @@ impl<'a, C, NC, A> FileCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The language of the timed text. - pub fn timed_text_language(mut self, new_value: &str) -> FileCopyCall<'a, C, NC, A> { + pub fn timed_text_language(mut self, new_value: &str) -> FileCopyCall<'a, C, A> { self._timed_text_language = Some(new_value.to_string()); self } @@ -4876,7 +4872,7 @@ impl<'a, C, NC, A> FileCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Whether to pin the head revision of the new copy. A file can have a maximum of 200 pinned revisions. - pub fn pinned(mut self, new_value: bool) -> FileCopyCall<'a, C, NC, A> { + pub fn pinned(mut self, new_value: bool) -> FileCopyCall<'a, C, A> { self._pinned = Some(new_value); self } @@ -4884,7 +4880,7 @@ impl<'a, C, NC, A> FileCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// If ocr is true, hints at the language to use. Valid values are ISO 639-1 codes. - pub fn ocr_language(mut self, new_value: &str) -> FileCopyCall<'a, C, NC, A> { + pub fn ocr_language(mut self, new_value: &str) -> FileCopyCall<'a, C, A> { self._ocr_language = Some(new_value.to_string()); self } @@ -4892,7 +4888,7 @@ impl<'a, C, NC, A> FileCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Whether to attempt OCR on .jpg, .png, .gif, or .pdf uploads. - pub fn ocr(mut self, new_value: bool) -> FileCopyCall<'a, C, NC, A> { + pub fn ocr(mut self, new_value: bool) -> FileCopyCall<'a, C, A> { self._ocr = Some(new_value); self } @@ -4900,7 +4896,7 @@ impl<'a, C, NC, A> FileCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Whether to convert this file to the corresponding Google Docs format. - pub fn convert(mut self, new_value: bool) -> FileCopyCall<'a, C, NC, A> { + pub fn convert(mut self, new_value: bool) -> FileCopyCall<'a, C, A> { self._convert = Some(new_value); self } @@ -4911,7 +4907,7 @@ impl<'a, C, NC, A> FileCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileCopyCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileCopyCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4932,7 +4928,7 @@ impl<'a, C, NC, A> FileCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FileCopyCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FileCopyCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4949,7 +4945,7 @@ impl<'a, C, NC, A> FileCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FileCopyCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FileCopyCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4987,19 +4983,19 @@ impl<'a, C, NC, A> FileCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct FileTrashCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FileTrashCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FileTrashCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FileTrashCall<'a, C, A> {} -impl<'a, C, NC, A> FileTrashCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FileTrashCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5131,7 +5127,7 @@ impl<'a, C, NC, A> FileTrashCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the file to trash. - pub fn file_id(mut self, new_value: &str) -> FileTrashCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> FileTrashCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -5142,7 +5138,7 @@ impl<'a, C, NC, A> FileTrashCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileTrashCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileTrashCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5163,7 +5159,7 @@ impl<'a, C, NC, A> FileTrashCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FileTrashCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FileTrashCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5180,7 +5176,7 @@ impl<'a, C, NC, A> FileTrashCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FileTrashCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FileTrashCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5218,18 +5214,18 @@ impl<'a, C, NC, A> FileTrashCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct FileEmptyTrashCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FileEmptyTrashCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FileEmptyTrashCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FileEmptyTrashCall<'a, C, A> {} -impl<'a, C, NC, A> FileEmptyTrashCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FileEmptyTrashCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5326,7 +5322,7 @@ impl<'a, C, NC, A> FileEmptyTrashCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileEmptyTrashCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileEmptyTrashCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5347,7 +5343,7 @@ impl<'a, C, NC, A> FileEmptyTrashCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FileEmptyTrashCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FileEmptyTrashCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5364,7 +5360,7 @@ impl<'a, C, NC, A> FileEmptyTrashCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FileEmptyTrashCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FileEmptyTrashCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5407,10 +5403,10 @@ impl<'a, C, NC, A> FileEmptyTrashCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct FileListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FileListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _q: Option, _projection: Option, _page_token: Option, @@ -5421,9 +5417,9 @@ pub struct FileListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FileListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FileListCall<'a, C, A> {} -impl<'a, C, NC, A> FileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FileListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5543,7 +5539,7 @@ impl<'a, C, NC, A> FileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Query string for searching files. - pub fn q(mut self, new_value: &str) -> FileListCall<'a, C, NC, A> { + pub fn q(mut self, new_value: &str) -> FileListCall<'a, C, A> { self._q = Some(new_value.to_string()); self } @@ -5551,7 +5547,7 @@ impl<'a, C, NC, A> FileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// This parameter is deprecated and has no function. - pub fn projection(mut self, new_value: &str) -> FileListCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> FileListCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -5559,7 +5555,7 @@ impl<'a, C, NC, A> FileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Page token for files. - pub fn page_token(mut self, new_value: &str) -> FileListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> FileListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -5567,7 +5563,7 @@ impl<'a, C, NC, A> FileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Maximum number of files to return. - pub fn max_results(mut self, new_value: i32) -> FileListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> FileListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -5575,7 +5571,7 @@ impl<'a, C, NC, A> FileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The body of items (files/documents) to which the query applies. - pub fn corpus(mut self, new_value: &str) -> FileListCall<'a, C, NC, A> { + pub fn corpus(mut self, new_value: &str) -> FileListCall<'a, C, A> { self._corpus = Some(new_value.to_string()); self } @@ -5586,7 +5582,7 @@ impl<'a, C, NC, A> FileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5607,7 +5603,7 @@ impl<'a, C, NC, A> FileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FileListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FileListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5624,7 +5620,7 @@ impl<'a, C, NC, A> FileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FileListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FileListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5662,19 +5658,19 @@ impl<'a, C, NC, A> FileListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct FileTouchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FileTouchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FileTouchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FileTouchCall<'a, C, A> {} -impl<'a, C, NC, A> FileTouchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FileTouchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5806,7 +5802,7 @@ impl<'a, C, NC, A> FileTouchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the file to update. - pub fn file_id(mut self, new_value: &str) -> FileTouchCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> FileTouchCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -5817,7 +5813,7 @@ impl<'a, C, NC, A> FileTouchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileTouchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileTouchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5838,7 +5834,7 @@ impl<'a, C, NC, A> FileTouchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FileTouchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FileTouchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5855,7 +5851,7 @@ impl<'a, C, NC, A> FileTouchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FileTouchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FileTouchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5912,10 +5908,10 @@ impl<'a, C, NC, A> FileTouchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .upload_resumable(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct FileUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FileUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _request: File, _file_id: String, _use_content_as_indexable_text: Option, @@ -5935,9 +5931,9 @@ pub struct FileUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FileUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FileUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> FileUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FileUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6226,7 +6222,7 @@ impl<'a, C, NC, A> FileUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &File) -> FileUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &File) -> FileUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6236,7 +6232,7 @@ impl<'a, C, NC, A> FileUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the file to update. - pub fn file_id(mut self, new_value: &str) -> FileUpdateCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> FileUpdateCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -6244,7 +6240,7 @@ impl<'a, C, NC, A> FileUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether to use the content as indexable text. - pub fn use_content_as_indexable_text(mut self, new_value: bool) -> FileUpdateCall<'a, C, NC, A> { + pub fn use_content_as_indexable_text(mut self, new_value: bool) -> FileUpdateCall<'a, C, A> { self._use_content_as_indexable_text = Some(new_value); self } @@ -6252,7 +6248,7 @@ impl<'a, C, NC, A> FileUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether to update the view date after successfully updating the file. - pub fn update_viewed_date(mut self, new_value: bool) -> FileUpdateCall<'a, C, NC, A> { + pub fn update_viewed_date(mut self, new_value: bool) -> FileUpdateCall<'a, C, A> { self._update_viewed_date = Some(new_value); self } @@ -6260,7 +6256,7 @@ impl<'a, C, NC, A> FileUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The timed text track name. - pub fn timed_text_track_name(mut self, new_value: &str) -> FileUpdateCall<'a, C, NC, A> { + pub fn timed_text_track_name(mut self, new_value: &str) -> FileUpdateCall<'a, C, A> { self._timed_text_track_name = Some(new_value.to_string()); self } @@ -6268,7 +6264,7 @@ impl<'a, C, NC, A> FileUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The language of the timed text. - pub fn timed_text_language(mut self, new_value: &str) -> FileUpdateCall<'a, C, NC, A> { + pub fn timed_text_language(mut self, new_value: &str) -> FileUpdateCall<'a, C, A> { self._timed_text_language = Some(new_value.to_string()); self } @@ -6276,7 +6272,7 @@ impl<'a, C, NC, A> FileUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether to set the modified date with the supplied modified date. - pub fn set_modified_date(mut self, new_value: bool) -> FileUpdateCall<'a, C, NC, A> { + pub fn set_modified_date(mut self, new_value: bool) -> FileUpdateCall<'a, C, A> { self._set_modified_date = Some(new_value); self } @@ -6284,7 +6280,7 @@ impl<'a, C, NC, A> FileUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Comma-separated list of parent IDs to remove. - pub fn remove_parents(mut self, new_value: &str) -> FileUpdateCall<'a, C, NC, A> { + pub fn remove_parents(mut self, new_value: &str) -> FileUpdateCall<'a, C, A> { self._remove_parents = Some(new_value.to_string()); self } @@ -6292,7 +6288,7 @@ impl<'a, C, NC, A> FileUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether to pin the new revision. A file can have a maximum of 200 pinned revisions. - pub fn pinned(mut self, new_value: bool) -> FileUpdateCall<'a, C, NC, A> { + pub fn pinned(mut self, new_value: bool) -> FileUpdateCall<'a, C, A> { self._pinned = Some(new_value); self } @@ -6300,7 +6296,7 @@ impl<'a, C, NC, A> FileUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// If ocr is true, hints at the language to use. Valid values are ISO 639-1 codes. - pub fn ocr_language(mut self, new_value: &str) -> FileUpdateCall<'a, C, NC, A> { + pub fn ocr_language(mut self, new_value: &str) -> FileUpdateCall<'a, C, A> { self._ocr_language = Some(new_value.to_string()); self } @@ -6308,7 +6304,7 @@ impl<'a, C, NC, A> FileUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether to attempt OCR on .jpg, .png, .gif, or .pdf uploads. - pub fn ocr(mut self, new_value: bool) -> FileUpdateCall<'a, C, NC, A> { + pub fn ocr(mut self, new_value: bool) -> FileUpdateCall<'a, C, A> { self._ocr = Some(new_value); self } @@ -6316,7 +6312,7 @@ impl<'a, C, NC, A> FileUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether a blob upload should create a new revision. If false, the blob data in the current head revision is replaced. If true or not set, a new blob is created as head revision, and previous revisions are preserved (causing increased use of the user's data storage quota). - pub fn new_revision(mut self, new_value: bool) -> FileUpdateCall<'a, C, NC, A> { + pub fn new_revision(mut self, new_value: bool) -> FileUpdateCall<'a, C, A> { self._new_revision = Some(new_value); self } @@ -6324,7 +6320,7 @@ impl<'a, C, NC, A> FileUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether to convert this file to the corresponding Google Docs format. - pub fn convert(mut self, new_value: bool) -> FileUpdateCall<'a, C, NC, A> { + pub fn convert(mut self, new_value: bool) -> FileUpdateCall<'a, C, A> { self._convert = Some(new_value); self } @@ -6332,7 +6328,7 @@ impl<'a, C, NC, A> FileUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Comma-separated list of parent IDs to add. - pub fn add_parents(mut self, new_value: &str) -> FileUpdateCall<'a, C, NC, A> { + pub fn add_parents(mut self, new_value: &str) -> FileUpdateCall<'a, C, A> { self._add_parents = Some(new_value.to_string()); self } @@ -6343,7 +6339,7 @@ impl<'a, C, NC, A> FileUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6364,7 +6360,7 @@ impl<'a, C, NC, A> FileUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FileUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FileUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6381,7 +6377,7 @@ impl<'a, C, NC, A> FileUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FileUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FileUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6419,19 +6415,19 @@ impl<'a, C, NC, A> FileUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct FileDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FileDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FileDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FileDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> FileDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FileDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6552,7 +6548,7 @@ impl<'a, C, NC, A> FileDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the file to delete. - pub fn file_id(mut self, new_value: &str) -> FileDeleteCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> FileDeleteCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -6563,7 +6559,7 @@ impl<'a, C, NC, A> FileDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6584,7 +6580,7 @@ impl<'a, C, NC, A> FileDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FileDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FileDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6601,7 +6597,7 @@ impl<'a, C, NC, A> FileDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FileDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FileDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6657,10 +6653,10 @@ impl<'a, C, NC, A> FileDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct FilePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FilePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _request: File, _file_id: String, _use_content_as_indexable_text: Option, @@ -6680,9 +6676,9 @@ pub struct FilePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FilePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FilePatchCall<'a, C, A> {} -impl<'a, C, NC, A> FilePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FilePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6857,7 +6853,7 @@ impl<'a, C, NC, A> FilePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &File) -> FilePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &File) -> FilePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6867,7 +6863,7 @@ impl<'a, C, NC, A> FilePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the file to update. - pub fn file_id(mut self, new_value: &str) -> FilePatchCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> FilePatchCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -6875,7 +6871,7 @@ impl<'a, C, NC, A> FilePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether to use the content as indexable text. - pub fn use_content_as_indexable_text(mut self, new_value: bool) -> FilePatchCall<'a, C, NC, A> { + pub fn use_content_as_indexable_text(mut self, new_value: bool) -> FilePatchCall<'a, C, A> { self._use_content_as_indexable_text = Some(new_value); self } @@ -6883,7 +6879,7 @@ impl<'a, C, NC, A> FilePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether to update the view date after successfully updating the file. - pub fn update_viewed_date(mut self, new_value: bool) -> FilePatchCall<'a, C, NC, A> { + pub fn update_viewed_date(mut self, new_value: bool) -> FilePatchCall<'a, C, A> { self._update_viewed_date = Some(new_value); self } @@ -6891,7 +6887,7 @@ impl<'a, C, NC, A> FilePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The timed text track name. - pub fn timed_text_track_name(mut self, new_value: &str) -> FilePatchCall<'a, C, NC, A> { + pub fn timed_text_track_name(mut self, new_value: &str) -> FilePatchCall<'a, C, A> { self._timed_text_track_name = Some(new_value.to_string()); self } @@ -6899,7 +6895,7 @@ impl<'a, C, NC, A> FilePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The language of the timed text. - pub fn timed_text_language(mut self, new_value: &str) -> FilePatchCall<'a, C, NC, A> { + pub fn timed_text_language(mut self, new_value: &str) -> FilePatchCall<'a, C, A> { self._timed_text_language = Some(new_value.to_string()); self } @@ -6907,7 +6903,7 @@ impl<'a, C, NC, A> FilePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether to set the modified date with the supplied modified date. - pub fn set_modified_date(mut self, new_value: bool) -> FilePatchCall<'a, C, NC, A> { + pub fn set_modified_date(mut self, new_value: bool) -> FilePatchCall<'a, C, A> { self._set_modified_date = Some(new_value); self } @@ -6915,7 +6911,7 @@ impl<'a, C, NC, A> FilePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Comma-separated list of parent IDs to remove. - pub fn remove_parents(mut self, new_value: &str) -> FilePatchCall<'a, C, NC, A> { + pub fn remove_parents(mut self, new_value: &str) -> FilePatchCall<'a, C, A> { self._remove_parents = Some(new_value.to_string()); self } @@ -6923,7 +6919,7 @@ impl<'a, C, NC, A> FilePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether to pin the new revision. A file can have a maximum of 200 pinned revisions. - pub fn pinned(mut self, new_value: bool) -> FilePatchCall<'a, C, NC, A> { + pub fn pinned(mut self, new_value: bool) -> FilePatchCall<'a, C, A> { self._pinned = Some(new_value); self } @@ -6931,7 +6927,7 @@ impl<'a, C, NC, A> FilePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// If ocr is true, hints at the language to use. Valid values are ISO 639-1 codes. - pub fn ocr_language(mut self, new_value: &str) -> FilePatchCall<'a, C, NC, A> { + pub fn ocr_language(mut self, new_value: &str) -> FilePatchCall<'a, C, A> { self._ocr_language = Some(new_value.to_string()); self } @@ -6939,7 +6935,7 @@ impl<'a, C, NC, A> FilePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether to attempt OCR on .jpg, .png, .gif, or .pdf uploads. - pub fn ocr(mut self, new_value: bool) -> FilePatchCall<'a, C, NC, A> { + pub fn ocr(mut self, new_value: bool) -> FilePatchCall<'a, C, A> { self._ocr = Some(new_value); self } @@ -6947,7 +6943,7 @@ impl<'a, C, NC, A> FilePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether a blob upload should create a new revision. If false, the blob data in the current head revision is replaced. If true or not set, a new blob is created as head revision, and previous revisions are preserved (causing increased use of the user's data storage quota). - pub fn new_revision(mut self, new_value: bool) -> FilePatchCall<'a, C, NC, A> { + pub fn new_revision(mut self, new_value: bool) -> FilePatchCall<'a, C, A> { self._new_revision = Some(new_value); self } @@ -6955,7 +6951,7 @@ impl<'a, C, NC, A> FilePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether to convert this file to the corresponding Google Docs format. - pub fn convert(mut self, new_value: bool) -> FilePatchCall<'a, C, NC, A> { + pub fn convert(mut self, new_value: bool) -> FilePatchCall<'a, C, A> { self._convert = Some(new_value); self } @@ -6963,7 +6959,7 @@ impl<'a, C, NC, A> FilePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Comma-separated list of parent IDs to add. - pub fn add_parents(mut self, new_value: &str) -> FilePatchCall<'a, C, NC, A> { + pub fn add_parents(mut self, new_value: &str) -> FilePatchCall<'a, C, A> { self._add_parents = Some(new_value.to_string()); self } @@ -6974,7 +6970,7 @@ impl<'a, C, NC, A> FilePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FilePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FilePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6995,7 +6991,7 @@ impl<'a, C, NC, A> FilePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FilePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FilePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7012,7 +7008,7 @@ impl<'a, C, NC, A> FilePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FilePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FilePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7060,10 +7056,10 @@ impl<'a, C, NC, A> FilePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct FileGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FileGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _update_viewed_date: Option, _revision_id: Option, @@ -7075,9 +7071,9 @@ pub struct FileGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FileGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FileGetCall<'a, C, A> {} -impl<'a, C, NC, A> FileGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FileGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7240,7 +7236,7 @@ impl<'a, C, NC, A> FileGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// The ID for the file in question. - pub fn file_id(mut self, new_value: &str) -> FileGetCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> FileGetCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -7248,7 +7244,7 @@ impl<'a, C, NC, A> FileGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Whether to update the view date after successfully retrieving the file. - pub fn update_viewed_date(mut self, new_value: bool) -> FileGetCall<'a, C, NC, A> { + pub fn update_viewed_date(mut self, new_value: bool) -> FileGetCall<'a, C, A> { self._update_viewed_date = Some(new_value); self } @@ -7256,7 +7252,7 @@ impl<'a, C, NC, A> FileGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Specifies the Revision ID that should be downloaded. Ignored unless alt=media is specified. - pub fn revision_id(mut self, new_value: &str) -> FileGetCall<'a, C, NC, A> { + pub fn revision_id(mut self, new_value: &str) -> FileGetCall<'a, C, A> { self._revision_id = Some(new_value.to_string()); self } @@ -7264,7 +7260,7 @@ impl<'a, C, NC, A> FileGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// This parameter is deprecated and has no function. - pub fn projection(mut self, new_value: &str) -> FileGetCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> FileGetCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -7272,7 +7268,7 @@ impl<'a, C, NC, A> FileGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Specifies the type of resource representation to return. The default is 'json' to return file metadata. Specifying 'media' will cause the file content to be returned. - pub fn alt(mut self, new_value: &str) -> FileGetCall<'a, C, NC, A> { + pub fn alt(mut self, new_value: &str) -> FileGetCall<'a, C, A> { self._alt = Some(new_value.to_string()); self } @@ -7280,7 +7276,7 @@ impl<'a, C, NC, A> FileGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Whether the user is acknowledging the risk of downloading known malware or other abusive files. Ignored unless alt=media is specified. - pub fn acknowledge_abuse(mut self, new_value: bool) -> FileGetCall<'a, C, NC, A> { + pub fn acknowledge_abuse(mut self, new_value: bool) -> FileGetCall<'a, C, A> { self._acknowledge_abuse = Some(new_value); self } @@ -7291,7 +7287,7 @@ impl<'a, C, NC, A> FileGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FileGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7312,7 +7308,7 @@ impl<'a, C, NC, A> FileGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FileGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FileGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7329,7 +7325,7 @@ impl<'a, C, NC, A> FileGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FileGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FileGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7370,10 +7366,10 @@ impl<'a, C, NC, A> FileGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct AboutGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AboutGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _start_change_id: Option, _max_change_id_count: Option, _include_subscribed: Option, @@ -7382,9 +7378,9 @@ pub struct AboutGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AboutGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AboutGetCall<'a, C, A> {} -impl<'a, C, NC, A> AboutGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AboutGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7498,7 +7494,7 @@ impl<'a, C, NC, A> AboutGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Change ID to start counting from when calculating number of remaining change IDs - pub fn start_change_id(mut self, new_value: &str) -> AboutGetCall<'a, C, NC, A> { + pub fn start_change_id(mut self, new_value: &str) -> AboutGetCall<'a, C, A> { self._start_change_id = Some(new_value.to_string()); self } @@ -7506,7 +7502,7 @@ impl<'a, C, NC, A> AboutGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Maximum number of remaining change IDs to count - pub fn max_change_id_count(mut self, new_value: i64) -> AboutGetCall<'a, C, NC, A> { + pub fn max_change_id_count(mut self, new_value: i64) -> AboutGetCall<'a, C, A> { self._max_change_id_count = Some(new_value); self } @@ -7514,7 +7510,7 @@ impl<'a, C, NC, A> AboutGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// When calculating the number of remaining change IDs, whether to include public files the user has opened and shared files. When set to false, this counts only change IDs for owned files and any shared or public files that the user has explicitly added to a folder they own. - pub fn include_subscribed(mut self, new_value: bool) -> AboutGetCall<'a, C, NC, A> { + pub fn include_subscribed(mut self, new_value: bool) -> AboutGetCall<'a, C, A> { self._include_subscribed = Some(new_value); self } @@ -7525,7 +7521,7 @@ impl<'a, C, NC, A> AboutGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AboutGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AboutGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7546,7 +7542,7 @@ impl<'a, C, NC, A> AboutGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AboutGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AboutGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7563,7 +7559,7 @@ impl<'a, C, NC, A> AboutGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AboutGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AboutGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7603,10 +7599,10 @@ impl<'a, C, NC, A> AboutGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .upload(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct RealtimeUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RealtimeUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _base_revision: Option, _delegate: Option<&'a mut Delegate>, @@ -7614,9 +7610,9 @@ pub struct RealtimeUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RealtimeUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RealtimeUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> RealtimeUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RealtimeUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7849,7 +7845,7 @@ impl<'a, C, NC, A> RealtimeUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the file that the Realtime API data model is associated with. - pub fn file_id(mut self, new_value: &str) -> RealtimeUpdateCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> RealtimeUpdateCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -7857,7 +7853,7 @@ impl<'a, C, NC, A> RealtimeUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The revision of the model to diff the uploaded model against. If set, the uploaded model is diffed against the provided revision and those differences are merged with any changes made to the model after the provided revision. If not set, the uploaded model replaces the current model on the server. - pub fn base_revision(mut self, new_value: &str) -> RealtimeUpdateCall<'a, C, NC, A> { + pub fn base_revision(mut self, new_value: &str) -> RealtimeUpdateCall<'a, C, A> { self._base_revision = Some(new_value.to_string()); self } @@ -7868,7 +7864,7 @@ impl<'a, C, NC, A> RealtimeUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RealtimeUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RealtimeUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7889,7 +7885,7 @@ impl<'a, C, NC, A> RealtimeUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RealtimeUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RealtimeUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7906,7 +7902,7 @@ impl<'a, C, NC, A> RealtimeUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RealtimeUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RealtimeUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7948,10 +7944,10 @@ impl<'a, C, NC, A> RealtimeUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct RealtimeGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RealtimeGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _revision: Option, _delegate: Option<&'a mut Delegate>, @@ -7959,9 +7955,9 @@ pub struct RealtimeGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RealtimeGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RealtimeGetCall<'a, C, A> {} -impl<'a, C, NC, A> RealtimeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RealtimeGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8085,7 +8081,7 @@ impl<'a, C, NC, A> RealtimeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the file that the Realtime API data model is associated with. - pub fn file_id(mut self, new_value: &str) -> RealtimeGetCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> RealtimeGetCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -8093,7 +8089,7 @@ impl<'a, C, NC, A> RealtimeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The revision of the Realtime API data model to export. Revisions start at 1 (the initial empty data model) and are incremented with each change. If this parameter is excluded, the most recent data model will be returned. - pub fn revision(mut self, new_value: i32) -> RealtimeGetCall<'a, C, NC, A> { + pub fn revision(mut self, new_value: i32) -> RealtimeGetCall<'a, C, A> { self._revision = Some(new_value); self } @@ -8104,7 +8100,7 @@ impl<'a, C, NC, A> RealtimeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RealtimeGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RealtimeGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8125,7 +8121,7 @@ impl<'a, C, NC, A> RealtimeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RealtimeGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RealtimeGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8142,7 +8138,7 @@ impl<'a, C, NC, A> RealtimeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RealtimeGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RealtimeGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8180,19 +8176,19 @@ impl<'a, C, NC, A> RealtimeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct AppGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AppGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _app_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AppGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AppGetCall<'a, C, A> {} -impl<'a, C, NC, A> AppGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AppGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8324,7 +8320,7 @@ impl<'a, C, NC, A> AppGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// we provide this method for API completeness. /// /// The ID of the app. - pub fn app_id(mut self, new_value: &str) -> AppGetCall<'a, C, NC, A> { + pub fn app_id(mut self, new_value: &str) -> AppGetCall<'a, C, A> { self._app_id = new_value.to_string(); self } @@ -8335,7 +8331,7 @@ impl<'a, C, NC, A> AppGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AppGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AppGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8356,7 +8352,7 @@ impl<'a, C, NC, A> AppGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AppGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AppGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8373,7 +8369,7 @@ impl<'a, C, NC, A> AppGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AppGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AppGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8414,10 +8410,10 @@ impl<'a, C, NC, A> AppGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// .doit(); /// # } /// ``` -pub struct AppListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AppListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _language_code: Option, _app_filter_mime_types: Option, _app_filter_extensions: Option, @@ -8426,9 +8422,9 @@ pub struct AppListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AppListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AppListCall<'a, C, A> {} -impl<'a, C, NC, A> AppListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AppListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8542,7 +8538,7 @@ impl<'a, C, NC, A> AppListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// A language or locale code, as defined by BCP 47, with some extensions from Unicode's LDML format (http://www.unicode.org/reports/tr35/). - pub fn language_code(mut self, new_value: &str) -> AppListCall<'a, C, NC, A> { + pub fn language_code(mut self, new_value: &str) -> AppListCall<'a, C, A> { self._language_code = Some(new_value.to_string()); self } @@ -8550,7 +8546,7 @@ impl<'a, C, NC, A> AppListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// A comma-separated list of MIME types for open with filtering. All apps within the given app query scope which can open any of the given MIME types will be included in the response. If appFilterExtensions are provided as well, the result is a union of the two resulting app lists. - pub fn app_filter_mime_types(mut self, new_value: &str) -> AppListCall<'a, C, NC, A> { + pub fn app_filter_mime_types(mut self, new_value: &str) -> AppListCall<'a, C, A> { self._app_filter_mime_types = Some(new_value.to_string()); self } @@ -8558,7 +8554,7 @@ impl<'a, C, NC, A> AppListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// A comma-separated list of file extensions for open with filtering. All apps within the given app query scope which can open any of the given file extensions will be included in the response. If appFilterMimeTypes are provided as well, the result is a union of the two resulting app lists. - pub fn app_filter_extensions(mut self, new_value: &str) -> AppListCall<'a, C, NC, A> { + pub fn app_filter_extensions(mut self, new_value: &str) -> AppListCall<'a, C, A> { self._app_filter_extensions = Some(new_value.to_string()); self } @@ -8569,7 +8565,7 @@ impl<'a, C, NC, A> AppListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AppListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AppListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8590,7 +8586,7 @@ impl<'a, C, NC, A> AppListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AppListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AppListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8607,7 +8603,7 @@ impl<'a, C, NC, A> AppListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AppListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AppListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8645,10 +8641,10 @@ impl<'a, C, NC, A> AppListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct CommentDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CommentDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _comment_id: String, _delegate: Option<&'a mut Delegate>, @@ -8656,9 +8652,9 @@ pub struct CommentDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CommentDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CommentDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> CommentDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CommentDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8780,7 +8776,7 @@ impl<'a, C, NC, A> CommentDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> CommentDeleteCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> CommentDeleteCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -8790,7 +8786,7 @@ impl<'a, C, NC, A> CommentDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the comment. - pub fn comment_id(mut self, new_value: &str) -> CommentDeleteCall<'a, C, NC, A> { + pub fn comment_id(mut self, new_value: &str) -> CommentDeleteCall<'a, C, A> { self._comment_id = new_value.to_string(); self } @@ -8801,7 +8797,7 @@ impl<'a, C, NC, A> CommentDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8822,7 +8818,7 @@ impl<'a, C, NC, A> CommentDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CommentDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CommentDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8839,7 +8835,7 @@ impl<'a, C, NC, A> CommentDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CommentDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CommentDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8878,10 +8874,10 @@ impl<'a, C, NC, A> CommentDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct CommentGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CommentGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _comment_id: String, _include_deleted: Option, @@ -8890,9 +8886,9 @@ pub struct CommentGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CommentGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CommentGetCall<'a, C, A> {} -impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CommentGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9028,7 +9024,7 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> CommentGetCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> CommentGetCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -9038,7 +9034,7 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the comment. - pub fn comment_id(mut self, new_value: &str) -> CommentGetCall<'a, C, NC, A> { + pub fn comment_id(mut self, new_value: &str) -> CommentGetCall<'a, C, A> { self._comment_id = new_value.to_string(); self } @@ -9046,7 +9042,7 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// If set, this will succeed when retrieving a deleted comment, and will include any deleted replies. - pub fn include_deleted(mut self, new_value: bool) -> CommentGetCall<'a, C, NC, A> { + pub fn include_deleted(mut self, new_value: bool) -> CommentGetCall<'a, C, A> { self._include_deleted = Some(new_value); self } @@ -9057,7 +9053,7 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9078,7 +9074,7 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CommentGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CommentGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9095,7 +9091,7 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CommentGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CommentGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9139,10 +9135,10 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct CommentInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CommentInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _request: Comment, _file_id: String, _delegate: Option<&'a mut Delegate>, @@ -9150,9 +9146,9 @@ pub struct CommentInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CommentInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CommentInsertCall<'a, C, A> {} -impl<'a, C, NC, A> CommentInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CommentInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9291,7 +9287,7 @@ impl<'a, C, NC, A> CommentInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Comment) -> CommentInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Comment) -> CommentInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9301,7 +9297,7 @@ impl<'a, C, NC, A> CommentInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> CommentInsertCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> CommentInsertCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -9312,7 +9308,7 @@ impl<'a, C, NC, A> CommentInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9333,7 +9329,7 @@ impl<'a, C, NC, A> CommentInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CommentInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CommentInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9350,7 +9346,7 @@ impl<'a, C, NC, A> CommentInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CommentInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CommentInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9394,10 +9390,10 @@ impl<'a, C, NC, A> CommentInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct CommentPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CommentPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _request: Comment, _file_id: String, _comment_id: String, @@ -9406,9 +9402,9 @@ pub struct CommentPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CommentPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CommentPatchCall<'a, C, A> {} -impl<'a, C, NC, A> CommentPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CommentPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9548,7 +9544,7 @@ impl<'a, C, NC, A> CommentPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Comment) -> CommentPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Comment) -> CommentPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9558,7 +9554,7 @@ impl<'a, C, NC, A> CommentPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> CommentPatchCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> CommentPatchCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -9568,7 +9564,7 @@ impl<'a, C, NC, A> CommentPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the comment. - pub fn comment_id(mut self, new_value: &str) -> CommentPatchCall<'a, C, NC, A> { + pub fn comment_id(mut self, new_value: &str) -> CommentPatchCall<'a, C, A> { self._comment_id = new_value.to_string(); self } @@ -9579,7 +9575,7 @@ impl<'a, C, NC, A> CommentPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9600,7 +9596,7 @@ impl<'a, C, NC, A> CommentPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CommentPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CommentPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9617,7 +9613,7 @@ impl<'a, C, NC, A> CommentPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CommentPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CommentPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9661,10 +9657,10 @@ impl<'a, C, NC, A> CommentPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct CommentUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CommentUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _request: Comment, _file_id: String, _comment_id: String, @@ -9673,9 +9669,9 @@ pub struct CommentUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CommentUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CommentUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> CommentUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CommentUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9815,7 +9811,7 @@ impl<'a, C, NC, A> CommentUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Comment) -> CommentUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Comment) -> CommentUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9825,7 +9821,7 @@ impl<'a, C, NC, A> CommentUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> CommentUpdateCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> CommentUpdateCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -9835,7 +9831,7 @@ impl<'a, C, NC, A> CommentUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the comment. - pub fn comment_id(mut self, new_value: &str) -> CommentUpdateCall<'a, C, NC, A> { + pub fn comment_id(mut self, new_value: &str) -> CommentUpdateCall<'a, C, A> { self._comment_id = new_value.to_string(); self } @@ -9846,7 +9842,7 @@ impl<'a, C, NC, A> CommentUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9867,7 +9863,7 @@ impl<'a, C, NC, A> CommentUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CommentUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CommentUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9884,7 +9880,7 @@ impl<'a, C, NC, A> CommentUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CommentUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CommentUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9926,10 +9922,10 @@ impl<'a, C, NC, A> CommentUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct CommentListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CommentListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _updated_min: Option, _page_token: Option, @@ -9940,9 +9936,9 @@ pub struct CommentListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CommentListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CommentListCall<'a, C, A> {} -impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CommentListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10086,7 +10082,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> CommentListCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> CommentListCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -10094,7 +10090,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Only discussions that were updated after this timestamp will be returned. Formatted as an RFC 3339 timestamp. - pub fn updated_min(mut self, new_value: &str) -> CommentListCall<'a, C, NC, A> { + pub fn updated_min(mut self, new_value: &str) -> CommentListCall<'a, C, A> { self._updated_min = Some(new_value.to_string()); self } @@ -10102,7 +10098,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The continuation token, used to page through large result sets. To get the next page of results, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> CommentListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> CommentListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -10110,7 +10106,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The maximum number of discussions to include in the response, used for paging. - pub fn max_results(mut self, new_value: i32) -> CommentListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> CommentListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -10118,7 +10114,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// If set, all comments and replies, including deleted comments and replies (with content stripped) will be returned. - pub fn include_deleted(mut self, new_value: bool) -> CommentListCall<'a, C, NC, A> { + pub fn include_deleted(mut self, new_value: bool) -> CommentListCall<'a, C, A> { self._include_deleted = Some(new_value); self } @@ -10129,7 +10125,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10150,7 +10146,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CommentListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CommentListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10167,7 +10163,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CommentListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CommentListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10208,10 +10204,10 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct ChildrenListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChildrenListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _folder_id: String, _q: Option, _page_token: Option, @@ -10221,9 +10217,9 @@ pub struct ChildrenListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChildrenListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChildrenListCall<'a, C, A> {} -impl<'a, C, NC, A> ChildrenListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChildrenListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10364,7 +10360,7 @@ impl<'a, C, NC, A> ChildrenListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the folder. - pub fn folder_id(mut self, new_value: &str) -> ChildrenListCall<'a, C, NC, A> { + pub fn folder_id(mut self, new_value: &str) -> ChildrenListCall<'a, C, A> { self._folder_id = new_value.to_string(); self } @@ -10372,7 +10368,7 @@ impl<'a, C, NC, A> ChildrenListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Query string for searching children. - pub fn q(mut self, new_value: &str) -> ChildrenListCall<'a, C, NC, A> { + pub fn q(mut self, new_value: &str) -> ChildrenListCall<'a, C, A> { self._q = Some(new_value.to_string()); self } @@ -10380,7 +10376,7 @@ impl<'a, C, NC, A> ChildrenListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Page token for children. - pub fn page_token(mut self, new_value: &str) -> ChildrenListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ChildrenListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -10388,7 +10384,7 @@ impl<'a, C, NC, A> ChildrenListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Maximum number of children to return. - pub fn max_results(mut self, new_value: i32) -> ChildrenListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ChildrenListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -10399,7 +10395,7 @@ impl<'a, C, NC, A> ChildrenListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChildrenListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChildrenListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10420,7 +10416,7 @@ impl<'a, C, NC, A> ChildrenListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChildrenListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChildrenListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10437,7 +10433,7 @@ impl<'a, C, NC, A> ChildrenListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChildrenListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChildrenListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10475,10 +10471,10 @@ impl<'a, C, NC, A> ChildrenListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct ChildrenGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChildrenGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _folder_id: String, _child_id: String, _delegate: Option<&'a mut Delegate>, @@ -10486,9 +10482,9 @@ pub struct ChildrenGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChildrenGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChildrenGetCall<'a, C, A> {} -impl<'a, C, NC, A> ChildrenGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChildrenGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10621,7 +10617,7 @@ impl<'a, C, NC, A> ChildrenGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the folder. - pub fn folder_id(mut self, new_value: &str) -> ChildrenGetCall<'a, C, NC, A> { + pub fn folder_id(mut self, new_value: &str) -> ChildrenGetCall<'a, C, A> { self._folder_id = new_value.to_string(); self } @@ -10631,7 +10627,7 @@ impl<'a, C, NC, A> ChildrenGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the child. - pub fn child_id(mut self, new_value: &str) -> ChildrenGetCall<'a, C, NC, A> { + pub fn child_id(mut self, new_value: &str) -> ChildrenGetCall<'a, C, A> { self._child_id = new_value.to_string(); self } @@ -10642,7 +10638,7 @@ impl<'a, C, NC, A> ChildrenGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChildrenGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChildrenGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10663,7 +10659,7 @@ impl<'a, C, NC, A> ChildrenGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChildrenGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChildrenGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10680,7 +10676,7 @@ impl<'a, C, NC, A> ChildrenGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChildrenGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChildrenGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10718,10 +10714,10 @@ impl<'a, C, NC, A> ChildrenGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct ChildrenDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChildrenDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _folder_id: String, _child_id: String, _delegate: Option<&'a mut Delegate>, @@ -10729,9 +10725,9 @@ pub struct ChildrenDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChildrenDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChildrenDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ChildrenDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChildrenDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10853,7 +10849,7 @@ impl<'a, C, NC, A> ChildrenDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the folder. - pub fn folder_id(mut self, new_value: &str) -> ChildrenDeleteCall<'a, C, NC, A> { + pub fn folder_id(mut self, new_value: &str) -> ChildrenDeleteCall<'a, C, A> { self._folder_id = new_value.to_string(); self } @@ -10863,7 +10859,7 @@ impl<'a, C, NC, A> ChildrenDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the child. - pub fn child_id(mut self, new_value: &str) -> ChildrenDeleteCall<'a, C, NC, A> { + pub fn child_id(mut self, new_value: &str) -> ChildrenDeleteCall<'a, C, A> { self._child_id = new_value.to_string(); self } @@ -10874,7 +10870,7 @@ impl<'a, C, NC, A> ChildrenDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChildrenDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChildrenDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10895,7 +10891,7 @@ impl<'a, C, NC, A> ChildrenDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChildrenDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChildrenDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10912,7 +10908,7 @@ impl<'a, C, NC, A> ChildrenDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChildrenDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChildrenDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10956,10 +10952,10 @@ impl<'a, C, NC, A> ChildrenDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct ChildrenInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChildrenInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _request: ChildReference, _folder_id: String, _delegate: Option<&'a mut Delegate>, @@ -10967,9 +10963,9 @@ pub struct ChildrenInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChildrenInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChildrenInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ChildrenInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChildrenInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11108,7 +11104,7 @@ impl<'a, C, NC, A> ChildrenInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ChildReference) -> ChildrenInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ChildReference) -> ChildrenInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -11118,7 +11114,7 @@ impl<'a, C, NC, A> ChildrenInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the folder. - pub fn folder_id(mut self, new_value: &str) -> ChildrenInsertCall<'a, C, NC, A> { + pub fn folder_id(mut self, new_value: &str) -> ChildrenInsertCall<'a, C, A> { self._folder_id = new_value.to_string(); self } @@ -11129,7 +11125,7 @@ impl<'a, C, NC, A> ChildrenInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChildrenInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChildrenInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11150,7 +11146,7 @@ impl<'a, C, NC, A> ChildrenInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChildrenInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChildrenInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11167,7 +11163,7 @@ impl<'a, C, NC, A> ChildrenInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChildrenInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChildrenInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11211,19 +11207,19 @@ impl<'a, C, NC, A> ChildrenInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct ChannelStopCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChannelStopCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _request: Channel, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChannelStopCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChannelStopCall<'a, C, A> {} -impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChannelStopCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11326,7 +11322,7 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Channel) -> ChannelStopCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Channel) -> ChannelStopCall<'a, C, A> { self._request = new_value.clone(); self } @@ -11337,7 +11333,7 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelStopCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelStopCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11358,7 +11354,7 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChannelStopCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChannelStopCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11375,7 +11371,7 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChannelStopCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChannelStopCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11413,19 +11409,19 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct ParentListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ParentListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ParentListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ParentListCall<'a, C, A> {} -impl<'a, C, NC, A> ParentListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ParentListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11557,7 +11553,7 @@ impl<'a, C, NC, A> ParentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> ParentListCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> ParentListCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -11568,7 +11564,7 @@ impl<'a, C, NC, A> ParentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ParentListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ParentListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11589,7 +11585,7 @@ impl<'a, C, NC, A> ParentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ParentListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ParentListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11606,7 +11602,7 @@ impl<'a, C, NC, A> ParentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ParentListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ParentListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11644,10 +11640,10 @@ impl<'a, C, NC, A> ParentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct ParentDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ParentDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _parent_id: String, _delegate: Option<&'a mut Delegate>, @@ -11655,9 +11651,9 @@ pub struct ParentDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ParentDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ParentDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ParentDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ParentDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11779,7 +11775,7 @@ impl<'a, C, NC, A> ParentDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> ParentDeleteCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> ParentDeleteCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -11789,7 +11785,7 @@ impl<'a, C, NC, A> ParentDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the parent. - pub fn parent_id(mut self, new_value: &str) -> ParentDeleteCall<'a, C, NC, A> { + pub fn parent_id(mut self, new_value: &str) -> ParentDeleteCall<'a, C, A> { self._parent_id = new_value.to_string(); self } @@ -11800,7 +11796,7 @@ impl<'a, C, NC, A> ParentDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ParentDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ParentDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11821,7 +11817,7 @@ impl<'a, C, NC, A> ParentDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ParentDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ParentDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11838,7 +11834,7 @@ impl<'a, C, NC, A> ParentDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ParentDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ParentDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11882,10 +11878,10 @@ impl<'a, C, NC, A> ParentDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct ParentInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ParentInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _request: ParentReference, _file_id: String, _delegate: Option<&'a mut Delegate>, @@ -11893,9 +11889,9 @@ pub struct ParentInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ParentInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ParentInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ParentInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ParentInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12034,7 +12030,7 @@ impl<'a, C, NC, A> ParentInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ParentReference) -> ParentInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ParentReference) -> ParentInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -12044,7 +12040,7 @@ impl<'a, C, NC, A> ParentInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> ParentInsertCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> ParentInsertCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -12055,7 +12051,7 @@ impl<'a, C, NC, A> ParentInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ParentInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ParentInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12076,7 +12072,7 @@ impl<'a, C, NC, A> ParentInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ParentInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ParentInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12093,7 +12089,7 @@ impl<'a, C, NC, A> ParentInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ParentInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ParentInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12131,10 +12127,10 @@ impl<'a, C, NC, A> ParentInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct ParentGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ParentGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _parent_id: String, _delegate: Option<&'a mut Delegate>, @@ -12142,9 +12138,9 @@ pub struct ParentGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ParentGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ParentGetCall<'a, C, A> {} -impl<'a, C, NC, A> ParentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ParentGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12277,7 +12273,7 @@ impl<'a, C, NC, A> ParentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> ParentGetCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> ParentGetCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -12287,7 +12283,7 @@ impl<'a, C, NC, A> ParentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the parent. - pub fn parent_id(mut self, new_value: &str) -> ParentGetCall<'a, C, NC, A> { + pub fn parent_id(mut self, new_value: &str) -> ParentGetCall<'a, C, A> { self._parent_id = new_value.to_string(); self } @@ -12298,7 +12294,7 @@ impl<'a, C, NC, A> ParentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ParentGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ParentGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12319,7 +12315,7 @@ impl<'a, C, NC, A> ParentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ParentGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ParentGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12336,7 +12332,7 @@ impl<'a, C, NC, A> ParentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ParentGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ParentGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12380,10 +12376,10 @@ impl<'a, C, NC, A> ParentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct ReplyPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReplyPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _request: CommentReply, _file_id: String, _comment_id: String, @@ -12393,9 +12389,9 @@ pub struct ReplyPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReplyPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReplyPatchCall<'a, C, A> {} -impl<'a, C, NC, A> ReplyPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReplyPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12536,7 +12532,7 @@ impl<'a, C, NC, A> ReplyPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CommentReply) -> ReplyPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CommentReply) -> ReplyPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -12546,7 +12542,7 @@ impl<'a, C, NC, A> ReplyPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> ReplyPatchCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> ReplyPatchCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -12556,7 +12552,7 @@ impl<'a, C, NC, A> ReplyPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the comment. - pub fn comment_id(mut self, new_value: &str) -> ReplyPatchCall<'a, C, NC, A> { + pub fn comment_id(mut self, new_value: &str) -> ReplyPatchCall<'a, C, A> { self._comment_id = new_value.to_string(); self } @@ -12566,7 +12562,7 @@ impl<'a, C, NC, A> ReplyPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the reply. - pub fn reply_id(mut self, new_value: &str) -> ReplyPatchCall<'a, C, NC, A> { + pub fn reply_id(mut self, new_value: &str) -> ReplyPatchCall<'a, C, A> { self._reply_id = new_value.to_string(); self } @@ -12577,7 +12573,7 @@ impl<'a, C, NC, A> ReplyPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReplyPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReplyPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12598,7 +12594,7 @@ impl<'a, C, NC, A> ReplyPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReplyPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReplyPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12615,7 +12611,7 @@ impl<'a, C, NC, A> ReplyPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReplyPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReplyPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12656,10 +12652,10 @@ impl<'a, C, NC, A> ReplyPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct ReplyListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReplyListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _comment_id: String, _page_token: Option, @@ -12670,9 +12666,9 @@ pub struct ReplyListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReplyListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReplyListCall<'a, C, A> {} -impl<'a, C, NC, A> ReplyListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReplyListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12814,7 +12810,7 @@ impl<'a, C, NC, A> ReplyListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> ReplyListCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> ReplyListCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -12824,7 +12820,7 @@ impl<'a, C, NC, A> ReplyListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the comment. - pub fn comment_id(mut self, new_value: &str) -> ReplyListCall<'a, C, NC, A> { + pub fn comment_id(mut self, new_value: &str) -> ReplyListCall<'a, C, A> { self._comment_id = new_value.to_string(); self } @@ -12832,7 +12828,7 @@ impl<'a, C, NC, A> ReplyListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The continuation token, used to page through large result sets. To get the next page of results, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> ReplyListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ReplyListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -12840,7 +12836,7 @@ impl<'a, C, NC, A> ReplyListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The maximum number of replies to include in the response, used for paging. - pub fn max_results(mut self, new_value: i32) -> ReplyListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ReplyListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -12848,7 +12844,7 @@ impl<'a, C, NC, A> ReplyListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// If set, all replies, including deleted replies (with content stripped) will be returned. - pub fn include_deleted(mut self, new_value: bool) -> ReplyListCall<'a, C, NC, A> { + pub fn include_deleted(mut self, new_value: bool) -> ReplyListCall<'a, C, A> { self._include_deleted = Some(new_value); self } @@ -12859,7 +12855,7 @@ impl<'a, C, NC, A> ReplyListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReplyListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReplyListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12880,7 +12876,7 @@ impl<'a, C, NC, A> ReplyListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReplyListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReplyListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12897,7 +12893,7 @@ impl<'a, C, NC, A> ReplyListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReplyListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReplyListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12936,10 +12932,10 @@ impl<'a, C, NC, A> ReplyListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct ReplyGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReplyGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _comment_id: String, _reply_id: String, @@ -12949,9 +12945,9 @@ pub struct ReplyGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReplyGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReplyGetCall<'a, C, A> {} -impl<'a, C, NC, A> ReplyGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReplyGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13088,7 +13084,7 @@ impl<'a, C, NC, A> ReplyGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> ReplyGetCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> ReplyGetCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -13098,7 +13094,7 @@ impl<'a, C, NC, A> ReplyGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The ID of the comment. - pub fn comment_id(mut self, new_value: &str) -> ReplyGetCall<'a, C, NC, A> { + pub fn comment_id(mut self, new_value: &str) -> ReplyGetCall<'a, C, A> { self._comment_id = new_value.to_string(); self } @@ -13108,7 +13104,7 @@ impl<'a, C, NC, A> ReplyGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The ID of the reply. - pub fn reply_id(mut self, new_value: &str) -> ReplyGetCall<'a, C, NC, A> { + pub fn reply_id(mut self, new_value: &str) -> ReplyGetCall<'a, C, A> { self._reply_id = new_value.to_string(); self } @@ -13116,7 +13112,7 @@ impl<'a, C, NC, A> ReplyGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// If set, this will succeed when retrieving a deleted reply. - pub fn include_deleted(mut self, new_value: bool) -> ReplyGetCall<'a, C, NC, A> { + pub fn include_deleted(mut self, new_value: bool) -> ReplyGetCall<'a, C, A> { self._include_deleted = Some(new_value); self } @@ -13127,7 +13123,7 @@ impl<'a, C, NC, A> ReplyGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReplyGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReplyGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13148,7 +13144,7 @@ impl<'a, C, NC, A> ReplyGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReplyGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReplyGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13165,7 +13161,7 @@ impl<'a, C, NC, A> ReplyGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReplyGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReplyGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13209,10 +13205,10 @@ impl<'a, C, NC, A> ReplyGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct ReplyInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReplyInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _request: CommentReply, _file_id: String, _comment_id: String, @@ -13221,9 +13217,9 @@ pub struct ReplyInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReplyInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReplyInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ReplyInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReplyInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13363,7 +13359,7 @@ impl<'a, C, NC, A> ReplyInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CommentReply) -> ReplyInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CommentReply) -> ReplyInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13373,7 +13369,7 @@ impl<'a, C, NC, A> ReplyInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> ReplyInsertCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> ReplyInsertCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -13383,7 +13379,7 @@ impl<'a, C, NC, A> ReplyInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the comment. - pub fn comment_id(mut self, new_value: &str) -> ReplyInsertCall<'a, C, NC, A> { + pub fn comment_id(mut self, new_value: &str) -> ReplyInsertCall<'a, C, A> { self._comment_id = new_value.to_string(); self } @@ -13394,7 +13390,7 @@ impl<'a, C, NC, A> ReplyInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReplyInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReplyInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13415,7 +13411,7 @@ impl<'a, C, NC, A> ReplyInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReplyInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReplyInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13432,7 +13428,7 @@ impl<'a, C, NC, A> ReplyInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReplyInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReplyInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13470,10 +13466,10 @@ impl<'a, C, NC, A> ReplyInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct ReplyDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReplyDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _comment_id: String, _reply_id: String, @@ -13482,9 +13478,9 @@ pub struct ReplyDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReplyDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReplyDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ReplyDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReplyDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13607,7 +13603,7 @@ impl<'a, C, NC, A> ReplyDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> ReplyDeleteCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> ReplyDeleteCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -13617,7 +13613,7 @@ impl<'a, C, NC, A> ReplyDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the comment. - pub fn comment_id(mut self, new_value: &str) -> ReplyDeleteCall<'a, C, NC, A> { + pub fn comment_id(mut self, new_value: &str) -> ReplyDeleteCall<'a, C, A> { self._comment_id = new_value.to_string(); self } @@ -13627,7 +13623,7 @@ impl<'a, C, NC, A> ReplyDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the reply. - pub fn reply_id(mut self, new_value: &str) -> ReplyDeleteCall<'a, C, NC, A> { + pub fn reply_id(mut self, new_value: &str) -> ReplyDeleteCall<'a, C, A> { self._reply_id = new_value.to_string(); self } @@ -13638,7 +13634,7 @@ impl<'a, C, NC, A> ReplyDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReplyDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReplyDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13659,7 +13655,7 @@ impl<'a, C, NC, A> ReplyDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReplyDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReplyDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13676,7 +13672,7 @@ impl<'a, C, NC, A> ReplyDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReplyDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReplyDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13720,10 +13716,10 @@ impl<'a, C, NC, A> ReplyDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct ReplyUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReplyUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _request: CommentReply, _file_id: String, _comment_id: String, @@ -13733,9 +13729,9 @@ pub struct ReplyUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReplyUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReplyUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ReplyUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReplyUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13876,7 +13872,7 @@ impl<'a, C, NC, A> ReplyUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CommentReply) -> ReplyUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CommentReply) -> ReplyUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13886,7 +13882,7 @@ impl<'a, C, NC, A> ReplyUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> ReplyUpdateCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> ReplyUpdateCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -13896,7 +13892,7 @@ impl<'a, C, NC, A> ReplyUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the comment. - pub fn comment_id(mut self, new_value: &str) -> ReplyUpdateCall<'a, C, NC, A> { + pub fn comment_id(mut self, new_value: &str) -> ReplyUpdateCall<'a, C, A> { self._comment_id = new_value.to_string(); self } @@ -13906,7 +13902,7 @@ impl<'a, C, NC, A> ReplyUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the reply. - pub fn reply_id(mut self, new_value: &str) -> ReplyUpdateCall<'a, C, NC, A> { + pub fn reply_id(mut self, new_value: &str) -> ReplyUpdateCall<'a, C, A> { self._reply_id = new_value.to_string(); self } @@ -13917,7 +13913,7 @@ impl<'a, C, NC, A> ReplyUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReplyUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReplyUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13938,7 +13934,7 @@ impl<'a, C, NC, A> ReplyUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReplyUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReplyUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13955,7 +13951,7 @@ impl<'a, C, NC, A> ReplyUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReplyUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReplyUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13993,10 +13989,10 @@ impl<'a, C, NC, A> ReplyUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct PermissionDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PermissionDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _permission_id: String, _delegate: Option<&'a mut Delegate>, @@ -14004,9 +14000,9 @@ pub struct PermissionDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PermissionDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PermissionDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> PermissionDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PermissionDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14128,7 +14124,7 @@ impl<'a, C, NC, A> PermissionDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID for the file. - pub fn file_id(mut self, new_value: &str) -> PermissionDeleteCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> PermissionDeleteCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -14138,7 +14134,7 @@ impl<'a, C, NC, A> PermissionDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID for the permission. - pub fn permission_id(mut self, new_value: &str) -> PermissionDeleteCall<'a, C, NC, A> { + pub fn permission_id(mut self, new_value: &str) -> PermissionDeleteCall<'a, C, A> { self._permission_id = new_value.to_string(); self } @@ -14149,7 +14145,7 @@ impl<'a, C, NC, A> PermissionDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PermissionDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PermissionDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14170,7 +14166,7 @@ impl<'a, C, NC, A> PermissionDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PermissionDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PermissionDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14187,7 +14183,7 @@ impl<'a, C, NC, A> PermissionDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PermissionDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PermissionDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14233,10 +14229,10 @@ impl<'a, C, NC, A> PermissionDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct PermissionInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PermissionInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _request: Permission, _file_id: String, _send_notification_emails: Option, @@ -14246,9 +14242,9 @@ pub struct PermissionInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PermissionInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PermissionInsertCall<'a, C, A> {} -impl<'a, C, NC, A> PermissionInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PermissionInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14393,7 +14389,7 @@ impl<'a, C, NC, A> PermissionInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Permission) -> PermissionInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Permission) -> PermissionInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -14403,7 +14399,7 @@ impl<'a, C, NC, A> PermissionInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID for the file. - pub fn file_id(mut self, new_value: &str) -> PermissionInsertCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> PermissionInsertCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -14411,7 +14407,7 @@ impl<'a, C, NC, A> PermissionInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Whether to send notification emails when sharing to users or groups. This parameter is ignored and an email is sent if the role is owner. - pub fn send_notification_emails(mut self, new_value: bool) -> PermissionInsertCall<'a, C, NC, A> { + pub fn send_notification_emails(mut self, new_value: bool) -> PermissionInsertCall<'a, C, A> { self._send_notification_emails = Some(new_value); self } @@ -14419,7 +14415,7 @@ impl<'a, C, NC, A> PermissionInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// A custom message to include in notification emails. - pub fn email_message(mut self, new_value: &str) -> PermissionInsertCall<'a, C, NC, A> { + pub fn email_message(mut self, new_value: &str) -> PermissionInsertCall<'a, C, A> { self._email_message = Some(new_value.to_string()); self } @@ -14430,7 +14426,7 @@ impl<'a, C, NC, A> PermissionInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PermissionInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PermissionInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14451,7 +14447,7 @@ impl<'a, C, NC, A> PermissionInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PermissionInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PermissionInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14468,7 +14464,7 @@ impl<'a, C, NC, A> PermissionInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PermissionInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PermissionInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14513,10 +14509,10 @@ impl<'a, C, NC, A> PermissionInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct PermissionUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PermissionUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _request: Permission, _file_id: String, _permission_id: String, @@ -14526,9 +14522,9 @@ pub struct PermissionUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PermissionUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PermissionUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> PermissionUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PermissionUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14671,7 +14667,7 @@ impl<'a, C, NC, A> PermissionUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Permission) -> PermissionUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Permission) -> PermissionUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -14681,7 +14677,7 @@ impl<'a, C, NC, A> PermissionUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID for the file. - pub fn file_id(mut self, new_value: &str) -> PermissionUpdateCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> PermissionUpdateCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -14691,7 +14687,7 @@ impl<'a, C, NC, A> PermissionUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID for the permission. - pub fn permission_id(mut self, new_value: &str) -> PermissionUpdateCall<'a, C, NC, A> { + pub fn permission_id(mut self, new_value: &str) -> PermissionUpdateCall<'a, C, A> { self._permission_id = new_value.to_string(); self } @@ -14699,7 +14695,7 @@ impl<'a, C, NC, A> PermissionUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Whether changing a role to 'owner' downgrades the current owners to writers. Does nothing if the specified role is not 'owner'. - pub fn transfer_ownership(mut self, new_value: bool) -> PermissionUpdateCall<'a, C, NC, A> { + pub fn transfer_ownership(mut self, new_value: bool) -> PermissionUpdateCall<'a, C, A> { self._transfer_ownership = Some(new_value); self } @@ -14710,7 +14706,7 @@ impl<'a, C, NC, A> PermissionUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PermissionUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PermissionUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14731,7 +14727,7 @@ impl<'a, C, NC, A> PermissionUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PermissionUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PermissionUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14748,7 +14744,7 @@ impl<'a, C, NC, A> PermissionUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PermissionUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PermissionUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14793,10 +14789,10 @@ impl<'a, C, NC, A> PermissionUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct PermissionPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PermissionPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _request: Permission, _file_id: String, _permission_id: String, @@ -14806,9 +14802,9 @@ pub struct PermissionPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PermissionPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PermissionPatchCall<'a, C, A> {} -impl<'a, C, NC, A> PermissionPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PermissionPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14951,7 +14947,7 @@ impl<'a, C, NC, A> PermissionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Permission) -> PermissionPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Permission) -> PermissionPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -14961,7 +14957,7 @@ impl<'a, C, NC, A> PermissionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID for the file. - pub fn file_id(mut self, new_value: &str) -> PermissionPatchCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> PermissionPatchCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -14971,7 +14967,7 @@ impl<'a, C, NC, A> PermissionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID for the permission. - pub fn permission_id(mut self, new_value: &str) -> PermissionPatchCall<'a, C, NC, A> { + pub fn permission_id(mut self, new_value: &str) -> PermissionPatchCall<'a, C, A> { self._permission_id = new_value.to_string(); self } @@ -14979,7 +14975,7 @@ impl<'a, C, NC, A> PermissionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Whether changing a role to 'owner' downgrades the current owners to writers. Does nothing if the specified role is not 'owner'. - pub fn transfer_ownership(mut self, new_value: bool) -> PermissionPatchCall<'a, C, NC, A> { + pub fn transfer_ownership(mut self, new_value: bool) -> PermissionPatchCall<'a, C, A> { self._transfer_ownership = Some(new_value); self } @@ -14990,7 +14986,7 @@ impl<'a, C, NC, A> PermissionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PermissionPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PermissionPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15011,7 +15007,7 @@ impl<'a, C, NC, A> PermissionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PermissionPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PermissionPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15028,7 +15024,7 @@ impl<'a, C, NC, A> PermissionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PermissionPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PermissionPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15066,19 +15062,19 @@ impl<'a, C, NC, A> PermissionPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct PermissionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PermissionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PermissionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PermissionListCall<'a, C, A> {} -impl<'a, C, NC, A> PermissionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PermissionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15210,7 +15206,7 @@ impl<'a, C, NC, A> PermissionListCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID for the file. - pub fn file_id(mut self, new_value: &str) -> PermissionListCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> PermissionListCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -15221,7 +15217,7 @@ impl<'a, C, NC, A> PermissionListCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PermissionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PermissionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15242,7 +15238,7 @@ impl<'a, C, NC, A> PermissionListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PermissionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PermissionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15259,7 +15255,7 @@ impl<'a, C, NC, A> PermissionListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PermissionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PermissionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15297,10 +15293,10 @@ impl<'a, C, NC, A> PermissionListCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct PermissionGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PermissionGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _permission_id: String, _delegate: Option<&'a mut Delegate>, @@ -15308,9 +15304,9 @@ pub struct PermissionGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PermissionGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PermissionGetCall<'a, C, A> {} -impl<'a, C, NC, A> PermissionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PermissionGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15443,7 +15439,7 @@ impl<'a, C, NC, A> PermissionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID for the file. - pub fn file_id(mut self, new_value: &str) -> PermissionGetCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> PermissionGetCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -15453,7 +15449,7 @@ impl<'a, C, NC, A> PermissionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID for the permission. - pub fn permission_id(mut self, new_value: &str) -> PermissionGetCall<'a, C, NC, A> { + pub fn permission_id(mut self, new_value: &str) -> PermissionGetCall<'a, C, A> { self._permission_id = new_value.to_string(); self } @@ -15464,7 +15460,7 @@ impl<'a, C, NC, A> PermissionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PermissionGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PermissionGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15485,7 +15481,7 @@ impl<'a, C, NC, A> PermissionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PermissionGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PermissionGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15502,7 +15498,7 @@ impl<'a, C, NC, A> PermissionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PermissionGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PermissionGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15540,19 +15536,19 @@ impl<'a, C, NC, A> PermissionGetCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct PermissionGetIdForEmailCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PermissionGetIdForEmailCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _email: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PermissionGetIdForEmailCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PermissionGetIdForEmailCall<'a, C, A> {} -impl<'a, C, NC, A> PermissionGetIdForEmailCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PermissionGetIdForEmailCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15684,7 +15680,7 @@ impl<'a, C, NC, A> PermissionGetIdForEmailCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The email address for which to return a permission ID - pub fn email(mut self, new_value: &str) -> PermissionGetIdForEmailCall<'a, C, NC, A> { + pub fn email(mut self, new_value: &str) -> PermissionGetIdForEmailCall<'a, C, A> { self._email = new_value.to_string(); self } @@ -15695,7 +15691,7 @@ impl<'a, C, NC, A> PermissionGetIdForEmailCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PermissionGetIdForEmailCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PermissionGetIdForEmailCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15716,7 +15712,7 @@ impl<'a, C, NC, A> PermissionGetIdForEmailCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PermissionGetIdForEmailCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PermissionGetIdForEmailCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15733,7 +15729,7 @@ impl<'a, C, NC, A> PermissionGetIdForEmailCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PermissionGetIdForEmailCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PermissionGetIdForEmailCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15782,10 +15778,10 @@ impl<'a, C, NC, A> PermissionGetIdForEmailCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct ChangeWatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChangeWatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _request: Channel, _start_change_id: Option, _page_token: Option, @@ -15797,9 +15793,9 @@ pub struct ChangeWatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChangeWatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChangeWatchCall<'a, C, A> {} -impl<'a, C, NC, A> ChangeWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChangeWatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15928,7 +15924,7 @@ impl<'a, C, NC, A> ChangeWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Channel) -> ChangeWatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Channel) -> ChangeWatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -15936,7 +15932,7 @@ impl<'a, C, NC, A> ChangeWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Change ID to start listing changes from. - pub fn start_change_id(mut self, new_value: &str) -> ChangeWatchCall<'a, C, NC, A> { + pub fn start_change_id(mut self, new_value: &str) -> ChangeWatchCall<'a, C, A> { self._start_change_id = Some(new_value.to_string()); self } @@ -15944,7 +15940,7 @@ impl<'a, C, NC, A> ChangeWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Page token for changes. - pub fn page_token(mut self, new_value: &str) -> ChangeWatchCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ChangeWatchCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -15952,7 +15948,7 @@ impl<'a, C, NC, A> ChangeWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Maximum number of changes to return. - pub fn max_results(mut self, new_value: i32) -> ChangeWatchCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ChangeWatchCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -15960,7 +15956,7 @@ impl<'a, C, NC, A> ChangeWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Whether to include public files the user has opened and shared files. When set to false, the list only includes owned files plus any shared or public files the user has explicitly added to a folder they own. - pub fn include_subscribed(mut self, new_value: bool) -> ChangeWatchCall<'a, C, NC, A> { + pub fn include_subscribed(mut self, new_value: bool) -> ChangeWatchCall<'a, C, A> { self._include_subscribed = Some(new_value); self } @@ -15968,7 +15964,7 @@ impl<'a, C, NC, A> ChangeWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Whether to include deleted items. - pub fn include_deleted(mut self, new_value: bool) -> ChangeWatchCall<'a, C, NC, A> { + pub fn include_deleted(mut self, new_value: bool) -> ChangeWatchCall<'a, C, A> { self._include_deleted = Some(new_value); self } @@ -15979,7 +15975,7 @@ impl<'a, C, NC, A> ChangeWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChangeWatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChangeWatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16000,7 +15996,7 @@ impl<'a, C, NC, A> ChangeWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChangeWatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChangeWatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16017,7 +16013,7 @@ impl<'a, C, NC, A> ChangeWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChangeWatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChangeWatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16060,10 +16056,10 @@ impl<'a, C, NC, A> ChangeWatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct ChangeListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChangeListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _start_change_id: Option, _page_token: Option, _max_results: Option, @@ -16074,9 +16070,9 @@ pub struct ChangeListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChangeListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChangeListCall<'a, C, A> {} -impl<'a, C, NC, A> ChangeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChangeListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16196,7 +16192,7 @@ impl<'a, C, NC, A> ChangeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Change ID to start listing changes from. - pub fn start_change_id(mut self, new_value: &str) -> ChangeListCall<'a, C, NC, A> { + pub fn start_change_id(mut self, new_value: &str) -> ChangeListCall<'a, C, A> { self._start_change_id = Some(new_value.to_string()); self } @@ -16204,7 +16200,7 @@ impl<'a, C, NC, A> ChangeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Page token for changes. - pub fn page_token(mut self, new_value: &str) -> ChangeListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ChangeListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -16212,7 +16208,7 @@ impl<'a, C, NC, A> ChangeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Maximum number of changes to return. - pub fn max_results(mut self, new_value: i32) -> ChangeListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ChangeListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -16220,7 +16216,7 @@ impl<'a, C, NC, A> ChangeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether to include public files the user has opened and shared files. When set to false, the list only includes owned files plus any shared or public files the user has explicitly added to a folder they own. - pub fn include_subscribed(mut self, new_value: bool) -> ChangeListCall<'a, C, NC, A> { + pub fn include_subscribed(mut self, new_value: bool) -> ChangeListCall<'a, C, A> { self._include_subscribed = Some(new_value); self } @@ -16228,7 +16224,7 @@ impl<'a, C, NC, A> ChangeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether to include deleted items. - pub fn include_deleted(mut self, new_value: bool) -> ChangeListCall<'a, C, NC, A> { + pub fn include_deleted(mut self, new_value: bool) -> ChangeListCall<'a, C, A> { self._include_deleted = Some(new_value); self } @@ -16239,7 +16235,7 @@ impl<'a, C, NC, A> ChangeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChangeListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChangeListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16260,7 +16256,7 @@ impl<'a, C, NC, A> ChangeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChangeListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChangeListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16277,7 +16273,7 @@ impl<'a, C, NC, A> ChangeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChangeListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChangeListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16315,19 +16311,19 @@ impl<'a, C, NC, A> ChangeListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct ChangeGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChangeGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _change_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChangeGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChangeGetCall<'a, C, A> {} -impl<'a, C, NC, A> ChangeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChangeGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16459,7 +16455,7 @@ impl<'a, C, NC, A> ChangeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the change. - pub fn change_id(mut self, new_value: &str) -> ChangeGetCall<'a, C, NC, A> { + pub fn change_id(mut self, new_value: &str) -> ChangeGetCall<'a, C, A> { self._change_id = new_value.to_string(); self } @@ -16470,7 +16466,7 @@ impl<'a, C, NC, A> ChangeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChangeGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChangeGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16491,7 +16487,7 @@ impl<'a, C, NC, A> ChangeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChangeGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChangeGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16508,7 +16504,7 @@ impl<'a, C, NC, A> ChangeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChangeGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChangeGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16553,10 +16549,10 @@ impl<'a, C, NC, A> ChangeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct PropertyPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PropertyPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _request: Property, _file_id: String, _property_key: String, @@ -16566,9 +16562,9 @@ pub struct PropertyPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PropertyPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PropertyPatchCall<'a, C, A> {} -impl<'a, C, NC, A> PropertyPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PropertyPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16711,7 +16707,7 @@ impl<'a, C, NC, A> PropertyPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Property) -> PropertyPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Property) -> PropertyPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -16721,7 +16717,7 @@ impl<'a, C, NC, A> PropertyPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> PropertyPatchCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> PropertyPatchCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -16731,7 +16727,7 @@ impl<'a, C, NC, A> PropertyPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The key of the property. - pub fn property_key(mut self, new_value: &str) -> PropertyPatchCall<'a, C, NC, A> { + pub fn property_key(mut self, new_value: &str) -> PropertyPatchCall<'a, C, A> { self._property_key = new_value.to_string(); self } @@ -16739,7 +16735,7 @@ impl<'a, C, NC, A> PropertyPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// The visibility of the property. - pub fn visibility(mut self, new_value: &str) -> PropertyPatchCall<'a, C, NC, A> { + pub fn visibility(mut self, new_value: &str) -> PropertyPatchCall<'a, C, A> { self._visibility = Some(new_value.to_string()); self } @@ -16750,7 +16746,7 @@ impl<'a, C, NC, A> PropertyPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PropertyPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PropertyPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16771,7 +16767,7 @@ impl<'a, C, NC, A> PropertyPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PropertyPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PropertyPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16788,7 +16784,7 @@ impl<'a, C, NC, A> PropertyPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PropertyPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PropertyPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16827,10 +16823,10 @@ impl<'a, C, NC, A> PropertyPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct PropertyDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PropertyDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _property_key: String, _visibility: Option, @@ -16839,9 +16835,9 @@ pub struct PropertyDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PropertyDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PropertyDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> PropertyDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PropertyDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16966,7 +16962,7 @@ impl<'a, C, NC, A> PropertyDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> PropertyDeleteCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> PropertyDeleteCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -16976,7 +16972,7 @@ impl<'a, C, NC, A> PropertyDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The key of the property. - pub fn property_key(mut self, new_value: &str) -> PropertyDeleteCall<'a, C, NC, A> { + pub fn property_key(mut self, new_value: &str) -> PropertyDeleteCall<'a, C, A> { self._property_key = new_value.to_string(); self } @@ -16984,7 +16980,7 @@ impl<'a, C, NC, A> PropertyDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The visibility of the property. - pub fn visibility(mut self, new_value: &str) -> PropertyDeleteCall<'a, C, NC, A> { + pub fn visibility(mut self, new_value: &str) -> PropertyDeleteCall<'a, C, A> { self._visibility = Some(new_value.to_string()); self } @@ -16995,7 +16991,7 @@ impl<'a, C, NC, A> PropertyDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PropertyDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PropertyDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17016,7 +17012,7 @@ impl<'a, C, NC, A> PropertyDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PropertyDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PropertyDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17033,7 +17029,7 @@ impl<'a, C, NC, A> PropertyDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PropertyDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PropertyDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17077,10 +17073,10 @@ impl<'a, C, NC, A> PropertyDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct PropertyInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PropertyInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _request: Property, _file_id: String, _delegate: Option<&'a mut Delegate>, @@ -17088,9 +17084,9 @@ pub struct PropertyInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PropertyInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PropertyInsertCall<'a, C, A> {} -impl<'a, C, NC, A> PropertyInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PropertyInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17229,7 +17225,7 @@ impl<'a, C, NC, A> PropertyInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Property) -> PropertyInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Property) -> PropertyInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -17239,7 +17235,7 @@ impl<'a, C, NC, A> PropertyInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> PropertyInsertCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> PropertyInsertCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -17250,7 +17246,7 @@ impl<'a, C, NC, A> PropertyInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PropertyInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PropertyInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17271,7 +17267,7 @@ impl<'a, C, NC, A> PropertyInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PropertyInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PropertyInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17288,7 +17284,7 @@ impl<'a, C, NC, A> PropertyInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PropertyInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PropertyInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17326,19 +17322,19 @@ impl<'a, C, NC, A> PropertyInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct PropertyListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PropertyListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PropertyListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PropertyListCall<'a, C, A> {} -impl<'a, C, NC, A> PropertyListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PropertyListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17470,7 +17466,7 @@ impl<'a, C, NC, A> PropertyListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> PropertyListCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> PropertyListCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -17481,7 +17477,7 @@ impl<'a, C, NC, A> PropertyListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PropertyListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PropertyListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17502,7 +17498,7 @@ impl<'a, C, NC, A> PropertyListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PropertyListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PropertyListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17519,7 +17515,7 @@ impl<'a, C, NC, A> PropertyListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PropertyListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PropertyListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17564,10 +17560,10 @@ impl<'a, C, NC, A> PropertyListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct PropertyUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PropertyUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _request: Property, _file_id: String, _property_key: String, @@ -17577,9 +17573,9 @@ pub struct PropertyUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PropertyUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PropertyUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> PropertyUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PropertyUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17722,7 +17718,7 @@ impl<'a, C, NC, A> PropertyUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Property) -> PropertyUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Property) -> PropertyUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -17732,7 +17728,7 @@ impl<'a, C, NC, A> PropertyUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> PropertyUpdateCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> PropertyUpdateCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -17742,7 +17738,7 @@ impl<'a, C, NC, A> PropertyUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The key of the property. - pub fn property_key(mut self, new_value: &str) -> PropertyUpdateCall<'a, C, NC, A> { + pub fn property_key(mut self, new_value: &str) -> PropertyUpdateCall<'a, C, A> { self._property_key = new_value.to_string(); self } @@ -17750,7 +17746,7 @@ impl<'a, C, NC, A> PropertyUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The visibility of the property. - pub fn visibility(mut self, new_value: &str) -> PropertyUpdateCall<'a, C, NC, A> { + pub fn visibility(mut self, new_value: &str) -> PropertyUpdateCall<'a, C, A> { self._visibility = Some(new_value.to_string()); self } @@ -17761,7 +17757,7 @@ impl<'a, C, NC, A> PropertyUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PropertyUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PropertyUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17782,7 +17778,7 @@ impl<'a, C, NC, A> PropertyUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PropertyUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PropertyUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17799,7 +17795,7 @@ impl<'a, C, NC, A> PropertyUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PropertyUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PropertyUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17838,10 +17834,10 @@ impl<'a, C, NC, A> PropertyUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct PropertyGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PropertyGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _property_key: String, _visibility: Option, @@ -17850,9 +17846,9 @@ pub struct PropertyGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PropertyGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PropertyGetCall<'a, C, A> {} -impl<'a, C, NC, A> PropertyGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PropertyGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17988,7 +17984,7 @@ impl<'a, C, NC, A> PropertyGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> PropertyGetCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> PropertyGetCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -17998,7 +17994,7 @@ impl<'a, C, NC, A> PropertyGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The key of the property. - pub fn property_key(mut self, new_value: &str) -> PropertyGetCall<'a, C, NC, A> { + pub fn property_key(mut self, new_value: &str) -> PropertyGetCall<'a, C, A> { self._property_key = new_value.to_string(); self } @@ -18006,7 +18002,7 @@ impl<'a, C, NC, A> PropertyGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The visibility of the property. - pub fn visibility(mut self, new_value: &str) -> PropertyGetCall<'a, C, NC, A> { + pub fn visibility(mut self, new_value: &str) -> PropertyGetCall<'a, C, A> { self._visibility = Some(new_value.to_string()); self } @@ -18017,7 +18013,7 @@ impl<'a, C, NC, A> PropertyGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PropertyGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PropertyGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18038,7 +18034,7 @@ impl<'a, C, NC, A> PropertyGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PropertyGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PropertyGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18055,7 +18051,7 @@ impl<'a, C, NC, A> PropertyGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PropertyGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PropertyGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18093,10 +18089,10 @@ impl<'a, C, NC, A> PropertyGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct RevisionGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RevisionGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _revision_id: String, _delegate: Option<&'a mut Delegate>, @@ -18104,9 +18100,9 @@ pub struct RevisionGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RevisionGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RevisionGetCall<'a, C, A> {} -impl<'a, C, NC, A> RevisionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RevisionGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18239,7 +18235,7 @@ impl<'a, C, NC, A> RevisionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> RevisionGetCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> RevisionGetCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -18249,7 +18245,7 @@ impl<'a, C, NC, A> RevisionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the revision. - pub fn revision_id(mut self, new_value: &str) -> RevisionGetCall<'a, C, NC, A> { + pub fn revision_id(mut self, new_value: &str) -> RevisionGetCall<'a, C, A> { self._revision_id = new_value.to_string(); self } @@ -18260,7 +18256,7 @@ impl<'a, C, NC, A> RevisionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RevisionGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RevisionGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18281,7 +18277,7 @@ impl<'a, C, NC, A> RevisionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RevisionGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RevisionGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18298,7 +18294,7 @@ impl<'a, C, NC, A> RevisionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RevisionGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RevisionGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18336,10 +18332,10 @@ impl<'a, C, NC, A> RevisionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct RevisionDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RevisionDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _revision_id: String, _delegate: Option<&'a mut Delegate>, @@ -18347,9 +18343,9 @@ pub struct RevisionDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RevisionDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RevisionDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> RevisionDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RevisionDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18471,7 +18467,7 @@ impl<'a, C, NC, A> RevisionDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> RevisionDeleteCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> RevisionDeleteCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -18481,7 +18477,7 @@ impl<'a, C, NC, A> RevisionDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the revision. - pub fn revision_id(mut self, new_value: &str) -> RevisionDeleteCall<'a, C, NC, A> { + pub fn revision_id(mut self, new_value: &str) -> RevisionDeleteCall<'a, C, A> { self._revision_id = new_value.to_string(); self } @@ -18492,7 +18488,7 @@ impl<'a, C, NC, A> RevisionDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RevisionDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RevisionDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18513,7 +18509,7 @@ impl<'a, C, NC, A> RevisionDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RevisionDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RevisionDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18530,7 +18526,7 @@ impl<'a, C, NC, A> RevisionDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RevisionDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RevisionDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18574,10 +18570,10 @@ impl<'a, C, NC, A> RevisionDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct RevisionUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RevisionUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _request: Revision, _file_id: String, _revision_id: String, @@ -18586,9 +18582,9 @@ pub struct RevisionUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RevisionUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RevisionUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> RevisionUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RevisionUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18728,7 +18724,7 @@ impl<'a, C, NC, A> RevisionUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Revision) -> RevisionUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Revision) -> RevisionUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -18738,7 +18734,7 @@ impl<'a, C, NC, A> RevisionUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID for the file. - pub fn file_id(mut self, new_value: &str) -> RevisionUpdateCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> RevisionUpdateCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -18748,7 +18744,7 @@ impl<'a, C, NC, A> RevisionUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID for the revision. - pub fn revision_id(mut self, new_value: &str) -> RevisionUpdateCall<'a, C, NC, A> { + pub fn revision_id(mut self, new_value: &str) -> RevisionUpdateCall<'a, C, A> { self._revision_id = new_value.to_string(); self } @@ -18759,7 +18755,7 @@ impl<'a, C, NC, A> RevisionUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RevisionUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RevisionUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18780,7 +18776,7 @@ impl<'a, C, NC, A> RevisionUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RevisionUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RevisionUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18797,7 +18793,7 @@ impl<'a, C, NC, A> RevisionUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RevisionUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RevisionUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18835,19 +18831,19 @@ impl<'a, C, NC, A> RevisionUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct RevisionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RevisionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _file_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RevisionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RevisionListCall<'a, C, A> {} -impl<'a, C, NC, A> RevisionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RevisionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18979,7 +18975,7 @@ impl<'a, C, NC, A> RevisionListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the file. - pub fn file_id(mut self, new_value: &str) -> RevisionListCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> RevisionListCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -18990,7 +18986,7 @@ impl<'a, C, NC, A> RevisionListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RevisionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RevisionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19011,7 +19007,7 @@ impl<'a, C, NC, A> RevisionListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RevisionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RevisionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19028,7 +19024,7 @@ impl<'a, C, NC, A> RevisionListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RevisionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RevisionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19072,10 +19068,10 @@ impl<'a, C, NC, A> RevisionListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct RevisionPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RevisionPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Drive, + hub: &'a Drive, _request: Revision, _file_id: String, _revision_id: String, @@ -19084,9 +19080,9 @@ pub struct RevisionPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RevisionPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RevisionPatchCall<'a, C, A> {} -impl<'a, C, NC, A> RevisionPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RevisionPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19226,7 +19222,7 @@ impl<'a, C, NC, A> RevisionPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Revision) -> RevisionPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Revision) -> RevisionPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -19236,7 +19232,7 @@ impl<'a, C, NC, A> RevisionPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID for the file. - pub fn file_id(mut self, new_value: &str) -> RevisionPatchCall<'a, C, NC, A> { + pub fn file_id(mut self, new_value: &str) -> RevisionPatchCall<'a, C, A> { self._file_id = new_value.to_string(); self } @@ -19246,7 +19242,7 @@ impl<'a, C, NC, A> RevisionPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID for the revision. - pub fn revision_id(mut self, new_value: &str) -> RevisionPatchCall<'a, C, NC, A> { + pub fn revision_id(mut self, new_value: &str) -> RevisionPatchCall<'a, C, A> { self._revision_id = new_value.to_string(); self } @@ -19257,7 +19253,7 @@ impl<'a, C, NC, A> RevisionPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RevisionPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RevisionPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19278,7 +19274,7 @@ impl<'a, C, NC, A> RevisionPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RevisionPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RevisionPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19295,7 +19291,7 @@ impl<'a, C, NC, A> RevisionPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RevisionPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RevisionPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/fitness1/Cargo.toml b/gen/fitness1/Cargo.toml index 0b46ca45e7b..afc44b72439 100644 --- a/gen/fitness1/Cargo.toml +++ b/gen/fitness1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-fitness1" -version = "0.1.4+20150222" +version = "0.1.5+20150222" authors = ["Sebastian Thiel "] description = "A complete library to interact with fitness (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/fitness1" homepage = "https://developers.google.com/fit/rest/" -documentation = "http://byron.github.io/google-apis-rs/google-fitness1" +documentation = "http://byron.github.io/google-apis-rs/google_fitness1" license = "MIT" keywords = ["fitness", "google", "protocol", "web", "api"] diff --git a/gen/fitness1/README.md b/gen/fitness1/README.md index e54721d8a78..1e5b296a826 100644 --- a/gen/fitness1/README.md +++ b/gen/fitness1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-fitness1` library allows access to all features of the *Google fitness* service. -This documentation was generated from *fitness* crate version *0.1.4+20150222*, where *20150222* is the exact revision of the *fitness:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *fitness* crate version *0.1.5+20150222*, where *20150222* is the exact revision of the *fitness:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *fitness* *v1* API can be found at the [official documentation site](https://developers.google.com/fit/rest/). diff --git a/gen/fitness1/src/cmn.rs b/gen/fitness1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/fitness1/src/cmn.rs +++ b/gen/fitness1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/fitness1/src/lib.rs b/gen/fitness1/src/lib.rs index 3da9aa281a9..27585e1429a 100644 --- a/gen/fitness1/src/lib.rs +++ b/gen/fitness1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *fitness* crate version *0.1.4+20150222*, where *20150222* is the exact revision of the *fitness:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *fitness* crate version *0.1.5+20150222*, where *20150222* is the exact revision of the *fitness:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *fitness* *v1* API can be found at the //! [official documentation site](https://developers.google.com/fit/rest/). @@ -197,7 +197,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -314,34 +313,31 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Fitness { +pub struct Fitness { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Fitness {} +impl<'a, C, A> Hub for Fitness {} -impl<'a, C, NC, A> Fitness - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Fitness + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Fitness { + pub fn new(client: C, authenticator: A) -> Fitness { Fitness { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn users(&'a self) -> UserMethods<'a, C, NC, A> { + pub fn users(&'a self) -> UserMethods<'a, C, A> { UserMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -698,15 +694,15 @@ impl ResponseResult for DataSource {} /// let rb = hub.users(); /// # } /// ``` -pub struct UserMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fitness, + hub: &'a Fitness, } -impl<'a, C, NC, A> MethodsBuilder for UserMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for UserMethods<'a, C, A> {} -impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { +impl<'a, C, A> UserMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -717,7 +713,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// * `userId` - Retrieve a dataset for the person identified. Use me to indicate the authenticated user. Only me is supported at this time. /// * `dataSourceId` - The data stream ID of the data source that created the dataset. /// * `datasetId` - Dataset identifier that is a composite of the minimum data point start time and maximum data point end time represented as nanoseconds from the epoch. The ID is formatted like: "startTime-endTime" where startTime and endTime are 64 bit integers. - pub fn data_sources_datasets_get(&self, user_id: &str, data_source_id: &str, dataset_id: &str) -> UserDataSourceDatasetGetCall<'a, C, NC, A> { + pub fn data_sources_datasets_get(&self, user_id: &str, data_source_id: &str, dataset_id: &str) -> UserDataSourceDatasetGetCall<'a, C, A> { UserDataSourceDatasetGetCall { hub: self.hub, _user_id: user_id.to_string(), @@ -739,7 +735,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `userId` - Create the data source for the person identified. Use me to indicate the authenticated user. Only me is supported at this time. - pub fn data_sources_create(&self, request: &DataSource, user_id: &str) -> UserDataSourceCreateCall<'a, C, NC, A> { + pub fn data_sources_create(&self, request: &DataSource, user_id: &str) -> UserDataSourceCreateCall<'a, C, A> { UserDataSourceCreateCall { hub: self.hub, _request: request.clone(), @@ -759,7 +755,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// * `userId` - Delete a dataset for the person identified. Use me to indicate the authenticated user. Only me is supported at this time. /// * `dataSourceId` - The data stream ID of the data source that created the dataset. /// * `datasetId` - Dataset identifier that is a composite of the minimum data point start time and maximum data point end time represented as nanoseconds from the epoch. The ID is formatted like: "startTime-endTime" where startTime and endTime are 64 bit integers. - pub fn data_sources_datasets_delete(&self, user_id: &str, data_source_id: &str, dataset_id: &str) -> UserDataSourceDatasetDeleteCall<'a, C, NC, A> { + pub fn data_sources_datasets_delete(&self, user_id: &str, data_source_id: &str, dataset_id: &str) -> UserDataSourceDatasetDeleteCall<'a, C, A> { UserDataSourceDatasetDeleteCall { hub: self.hub, _user_id: user_id.to_string(), @@ -783,7 +779,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// * `userId` - Patch a dataset for the person identified. Use me to indicate the authenticated user. Only me is supported at this time. /// * `dataSourceId` - The data stream ID of the data source that created the dataset. /// * `datasetId` - Dataset identifier that is a composite of the minimum data point start time and maximum data point end time represented as nanoseconds from the epoch. The ID is formatted like: "startTime-endTime" where startTime and endTime are 64 bit integers. - pub fn data_sources_datasets_patch(&self, request: &Dataset, user_id: &str, data_source_id: &str, dataset_id: &str) -> UserDataSourceDatasetPatchCall<'a, C, NC, A> { + pub fn data_sources_datasets_patch(&self, request: &Dataset, user_id: &str, data_source_id: &str, dataset_id: &str) -> UserDataSourceDatasetPatchCall<'a, C, A> { UserDataSourceDatasetPatchCall { hub: self.hub, _request: request.clone(), @@ -805,7 +801,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `userId` - Delete a session for the person identified. Use me to indicate the authenticated user. Only me is supported at this time. /// * `sessionId` - The ID of the session to be deleted. - pub fn sessions_delete(&self, user_id: &str, session_id: &str) -> UserSessionDeleteCall<'a, C, NC, A> { + pub fn sessions_delete(&self, user_id: &str, session_id: &str) -> UserSessionDeleteCall<'a, C, A> { UserSessionDeleteCall { hub: self.hub, _user_id: user_id.to_string(), @@ -825,7 +821,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `userId` - Retrieve a data source for the person identified. Use me to indicate the authenticated user. Only me is supported at this time. /// * `dataSourceId` - The data stream ID of the data source to retrieve. - pub fn data_sources_get(&self, user_id: &str, data_source_id: &str) -> UserDataSourceGetCall<'a, C, NC, A> { + pub fn data_sources_get(&self, user_id: &str, data_source_id: &str) -> UserDataSourceGetCall<'a, C, A> { UserDataSourceGetCall { hub: self.hub, _user_id: user_id.to_string(), @@ -847,7 +843,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `userId` - Update the data source for the person identified. Use me to indicate the authenticated user. Only me is supported at this time. /// * `dataSourceId` - The data stream ID of the data source to update. - pub fn data_sources_update(&self, request: &DataSource, user_id: &str, data_source_id: &str) -> UserDataSourceUpdateCall<'a, C, NC, A> { + pub fn data_sources_update(&self, request: &DataSource, user_id: &str, data_source_id: &str) -> UserDataSourceUpdateCall<'a, C, A> { UserDataSourceUpdateCall { hub: self.hub, _request: request.clone(), @@ -866,7 +862,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// # Arguments /// /// * `userId` - List sessions for the person identified. Use me to indicate the authenticated user. Only me is supported at this time. - pub fn sessions_list(&self, user_id: &str) -> UserSessionListCall<'a, C, NC, A> { + pub fn sessions_list(&self, user_id: &str) -> UserSessionListCall<'a, C, A> { UserSessionListCall { hub: self.hub, _user_id: user_id.to_string(), @@ -889,7 +885,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `userId` - Create sessions for the person identified. Use me to indicate the authenticated user. Only me is supported at this time. /// * `sessionId` - The ID of the session to be created. - pub fn sessions_update(&self, request: &Session, user_id: &str, session_id: &str) -> UserSessionUpdateCall<'a, C, NC, A> { + pub fn sessions_update(&self, request: &Session, user_id: &str, session_id: &str) -> UserSessionUpdateCall<'a, C, A> { UserSessionUpdateCall { hub: self.hub, _request: request.clone(), @@ -913,7 +909,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `userId` - Update the data source for the person identified. Use me to indicate the authenticated user. Only me is supported at this time. /// * `dataSourceId` - The data stream ID of the data source to update. - pub fn data_sources_patch(&self, request: &DataSource, user_id: &str, data_source_id: &str) -> UserDataSourcePatchCall<'a, C, NC, A> { + pub fn data_sources_patch(&self, request: &DataSource, user_id: &str, data_source_id: &str) -> UserDataSourcePatchCall<'a, C, A> { UserDataSourcePatchCall { hub: self.hub, _request: request.clone(), @@ -932,7 +928,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// # Arguments /// /// * `userId` - List data sources for the person identified. Use me to indicate the authenticated user. Only me is supported at this time. - pub fn data_sources_list(&self, user_id: &str) -> UserDataSourceListCall<'a, C, NC, A> { + pub fn data_sources_list(&self, user_id: &str) -> UserDataSourceListCall<'a, C, A> { UserDataSourceListCall { hub: self.hub, _user_id: user_id.to_string(), @@ -984,10 +980,10 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct UserDataSourceDatasetGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserDataSourceDatasetGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fitness, + hub: &'a Fitness, _user_id: String, _data_source_id: String, _dataset_id: String, @@ -998,9 +994,9 @@ pub struct UserDataSourceDatasetGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserDataSourceDatasetGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserDataSourceDatasetGetCall<'a, C, A> {} -impl<'a, C, NC, A> UserDataSourceDatasetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserDataSourceDatasetGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1140,7 +1136,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetGetCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Retrieve a dataset for the person identified. Use me to indicate the authenticated user. Only me is supported at this time. - pub fn user_id(mut self, new_value: &str) -> UserDataSourceDatasetGetCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserDataSourceDatasetGetCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -1150,7 +1146,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetGetCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The data stream ID of the data source that created the dataset. - pub fn data_source_id(mut self, new_value: &str) -> UserDataSourceDatasetGetCall<'a, C, NC, A> { + pub fn data_source_id(mut self, new_value: &str) -> UserDataSourceDatasetGetCall<'a, C, A> { self._data_source_id = new_value.to_string(); self } @@ -1160,7 +1156,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetGetCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Dataset identifier that is a composite of the minimum data point start time and maximum data point end time represented as nanoseconds from the epoch. The ID is formatted like: "startTime-endTime" where startTime and endTime are 64 bit integers. - pub fn dataset_id(mut self, new_value: &str) -> UserDataSourceDatasetGetCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> UserDataSourceDatasetGetCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -1168,7 +1164,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetGetCall<'a, C, NC, A> where NC: hyper::n /// /// /// The continuation token, which is used to page through large datasets. To get the next page of a dataset, set this parameter to the value of nextPageToken from the previous response. Each subsequent call will yield a partial dataset with data point end timestamps that are strictly smaller than those in the previous partial response. - pub fn page_token(mut self, new_value: &str) -> UserDataSourceDatasetGetCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> UserDataSourceDatasetGetCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -1176,7 +1172,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetGetCall<'a, C, NC, A> where NC: hyper::n /// /// /// If specified, no more than this many data points will be included in the dataset. If the there are more data points in the dataset, nextPageToken will be set in the dataset response. - pub fn limit(mut self, new_value: i32) -> UserDataSourceDatasetGetCall<'a, C, NC, A> { + pub fn limit(mut self, new_value: i32) -> UserDataSourceDatasetGetCall<'a, C, A> { self._limit = Some(new_value); self } @@ -1187,7 +1183,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetGetCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDataSourceDatasetGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDataSourceDatasetGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1208,7 +1204,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetGetCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserDataSourceDatasetGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserDataSourceDatasetGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1225,7 +1221,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetGetCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserDataSourceDatasetGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserDataSourceDatasetGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1269,10 +1265,10 @@ impl<'a, C, NC, A> UserDataSourceDatasetGetCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct UserDataSourceCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserDataSourceCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fitness, + hub: &'a Fitness, _request: DataSource, _user_id: String, _delegate: Option<&'a mut Delegate>, @@ -1280,9 +1276,9 @@ pub struct UserDataSourceCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserDataSourceCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserDataSourceCreateCall<'a, C, A> {} -impl<'a, C, NC, A> UserDataSourceCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserDataSourceCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1421,7 +1417,7 @@ impl<'a, C, NC, A> UserDataSourceCreateCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &DataSource) -> UserDataSourceCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &DataSource) -> UserDataSourceCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1431,7 +1427,7 @@ impl<'a, C, NC, A> UserDataSourceCreateCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Create the data source for the person identified. Use me to indicate the authenticated user. Only me is supported at this time. - pub fn user_id(mut self, new_value: &str) -> UserDataSourceCreateCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserDataSourceCreateCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -1442,7 +1438,7 @@ impl<'a, C, NC, A> UserDataSourceCreateCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDataSourceCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDataSourceCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1463,7 +1459,7 @@ impl<'a, C, NC, A> UserDataSourceCreateCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserDataSourceCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserDataSourceCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1480,7 +1476,7 @@ impl<'a, C, NC, A> UserDataSourceCreateCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserDataSourceCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserDataSourceCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1520,10 +1516,10 @@ impl<'a, C, NC, A> UserDataSourceCreateCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct UserDataSourceDatasetDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserDataSourceDatasetDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fitness, + hub: &'a Fitness, _user_id: String, _data_source_id: String, _dataset_id: String, @@ -1534,9 +1530,9 @@ pub struct UserDataSourceDatasetDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserDataSourceDatasetDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserDataSourceDatasetDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> UserDataSourceDatasetDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserDataSourceDatasetDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1665,7 +1661,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetDeleteCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// Delete a dataset for the person identified. Use me to indicate the authenticated user. Only me is supported at this time. - pub fn user_id(mut self, new_value: &str) -> UserDataSourceDatasetDeleteCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserDataSourceDatasetDeleteCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -1675,7 +1671,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetDeleteCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The data stream ID of the data source that created the dataset. - pub fn data_source_id(mut self, new_value: &str) -> UserDataSourceDatasetDeleteCall<'a, C, NC, A> { + pub fn data_source_id(mut self, new_value: &str) -> UserDataSourceDatasetDeleteCall<'a, C, A> { self._data_source_id = new_value.to_string(); self } @@ -1685,7 +1681,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetDeleteCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// Dataset identifier that is a composite of the minimum data point start time and maximum data point end time represented as nanoseconds from the epoch. The ID is formatted like: "startTime-endTime" where startTime and endTime are 64 bit integers. - pub fn dataset_id(mut self, new_value: &str) -> UserDataSourceDatasetDeleteCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> UserDataSourceDatasetDeleteCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -1693,7 +1689,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetDeleteCall<'a, C, NC, A> where NC: hyper /// /// /// When the operation was performed on the client. - pub fn modified_time_millis(mut self, new_value: &str) -> UserDataSourceDatasetDeleteCall<'a, C, NC, A> { + pub fn modified_time_millis(mut self, new_value: &str) -> UserDataSourceDatasetDeleteCall<'a, C, A> { self._modified_time_millis = Some(new_value.to_string()); self } @@ -1701,7 +1697,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetDeleteCall<'a, C, NC, A> where NC: hyper /// /// /// The client's current time in milliseconds since epoch. - pub fn current_time_millis(mut self, new_value: &str) -> UserDataSourceDatasetDeleteCall<'a, C, NC, A> { + pub fn current_time_millis(mut self, new_value: &str) -> UserDataSourceDatasetDeleteCall<'a, C, A> { self._current_time_millis = Some(new_value.to_string()); self } @@ -1712,7 +1708,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetDeleteCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDataSourceDatasetDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDataSourceDatasetDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1733,7 +1729,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetDeleteCall<'a, C, NC, A> where NC: hyper /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserDataSourceDatasetDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserDataSourceDatasetDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1750,7 +1746,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetDeleteCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserDataSourceDatasetDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserDataSourceDatasetDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1795,10 +1791,10 @@ impl<'a, C, NC, A> UserDataSourceDatasetDeleteCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct UserDataSourceDatasetPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserDataSourceDatasetPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fitness, + hub: &'a Fitness, _request: Dataset, _user_id: String, _data_source_id: String, @@ -1809,9 +1805,9 @@ pub struct UserDataSourceDatasetPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserDataSourceDatasetPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserDataSourceDatasetPatchCall<'a, C, A> {} -impl<'a, C, NC, A> UserDataSourceDatasetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserDataSourceDatasetPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1955,7 +1951,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetPatchCall<'a, C, NC, A> where NC: hyper: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Dataset) -> UserDataSourceDatasetPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Dataset) -> UserDataSourceDatasetPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1965,7 +1961,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetPatchCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Patch a dataset for the person identified. Use me to indicate the authenticated user. Only me is supported at this time. - pub fn user_id(mut self, new_value: &str) -> UserDataSourceDatasetPatchCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserDataSourceDatasetPatchCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -1975,7 +1971,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetPatchCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The data stream ID of the data source that created the dataset. - pub fn data_source_id(mut self, new_value: &str) -> UserDataSourceDatasetPatchCall<'a, C, NC, A> { + pub fn data_source_id(mut self, new_value: &str) -> UserDataSourceDatasetPatchCall<'a, C, A> { self._data_source_id = new_value.to_string(); self } @@ -1985,7 +1981,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetPatchCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Dataset identifier that is a composite of the minimum data point start time and maximum data point end time represented as nanoseconds from the epoch. The ID is formatted like: "startTime-endTime" where startTime and endTime are 64 bit integers. - pub fn dataset_id(mut self, new_value: &str) -> UserDataSourceDatasetPatchCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> UserDataSourceDatasetPatchCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -1993,7 +1989,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetPatchCall<'a, C, NC, A> where NC: hyper: /// /// /// The client's current time in milliseconds since epoch. Note that the minStartTimeNs and maxEndTimeNs properties in the request body are in nanoseconds instead of milliseconds. - pub fn current_time_millis(mut self, new_value: &str) -> UserDataSourceDatasetPatchCall<'a, C, NC, A> { + pub fn current_time_millis(mut self, new_value: &str) -> UserDataSourceDatasetPatchCall<'a, C, A> { self._current_time_millis = Some(new_value.to_string()); self } @@ -2004,7 +2000,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetPatchCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDataSourceDatasetPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDataSourceDatasetPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2025,7 +2021,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetPatchCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserDataSourceDatasetPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserDataSourceDatasetPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2042,7 +2038,7 @@ impl<'a, C, NC, A> UserDataSourceDatasetPatchCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserDataSourceDatasetPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserDataSourceDatasetPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2081,10 +2077,10 @@ impl<'a, C, NC, A> UserDataSourceDatasetPatchCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct UserSessionDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserSessionDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fitness, + hub: &'a Fitness, _user_id: String, _session_id: String, _current_time_millis: Option, @@ -2093,9 +2089,9 @@ pub struct UserSessionDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserSessionDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserSessionDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> UserSessionDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserSessionDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2220,7 +2216,7 @@ impl<'a, C, NC, A> UserSessionDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Delete a session for the person identified. Use me to indicate the authenticated user. Only me is supported at this time. - pub fn user_id(mut self, new_value: &str) -> UserSessionDeleteCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserSessionDeleteCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -2230,7 +2226,7 @@ impl<'a, C, NC, A> UserSessionDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the session to be deleted. - pub fn session_id(mut self, new_value: &str) -> UserSessionDeleteCall<'a, C, NC, A> { + pub fn session_id(mut self, new_value: &str) -> UserSessionDeleteCall<'a, C, A> { self._session_id = new_value.to_string(); self } @@ -2238,7 +2234,7 @@ impl<'a, C, NC, A> UserSessionDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The client's current time in milliseconds since epoch. - pub fn current_time_millis(mut self, new_value: &str) -> UserSessionDeleteCall<'a, C, NC, A> { + pub fn current_time_millis(mut self, new_value: &str) -> UserSessionDeleteCall<'a, C, A> { self._current_time_millis = Some(new_value.to_string()); self } @@ -2249,7 +2245,7 @@ impl<'a, C, NC, A> UserSessionDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserSessionDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserSessionDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2270,7 +2266,7 @@ impl<'a, C, NC, A> UserSessionDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserSessionDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserSessionDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2287,7 +2283,7 @@ impl<'a, C, NC, A> UserSessionDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserSessionDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserSessionDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2325,10 +2321,10 @@ impl<'a, C, NC, A> UserSessionDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct UserDataSourceGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserDataSourceGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fitness, + hub: &'a Fitness, _user_id: String, _data_source_id: String, _delegate: Option<&'a mut Delegate>, @@ -2336,9 +2332,9 @@ pub struct UserDataSourceGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserDataSourceGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserDataSourceGetCall<'a, C, A> {} -impl<'a, C, NC, A> UserDataSourceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserDataSourceGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2471,7 +2467,7 @@ impl<'a, C, NC, A> UserDataSourceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Retrieve a data source for the person identified. Use me to indicate the authenticated user. Only me is supported at this time. - pub fn user_id(mut self, new_value: &str) -> UserDataSourceGetCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserDataSourceGetCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -2481,7 +2477,7 @@ impl<'a, C, NC, A> UserDataSourceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The data stream ID of the data source to retrieve. - pub fn data_source_id(mut self, new_value: &str) -> UserDataSourceGetCall<'a, C, NC, A> { + pub fn data_source_id(mut self, new_value: &str) -> UserDataSourceGetCall<'a, C, A> { self._data_source_id = new_value.to_string(); self } @@ -2492,7 +2488,7 @@ impl<'a, C, NC, A> UserDataSourceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDataSourceGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDataSourceGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2513,7 +2509,7 @@ impl<'a, C, NC, A> UserDataSourceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserDataSourceGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserDataSourceGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2530,7 +2526,7 @@ impl<'a, C, NC, A> UserDataSourceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserDataSourceGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserDataSourceGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2576,10 +2572,10 @@ impl<'a, C, NC, A> UserDataSourceGetCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct UserDataSourceUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserDataSourceUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fitness, + hub: &'a Fitness, _request: DataSource, _user_id: String, _data_source_id: String, @@ -2588,9 +2584,9 @@ pub struct UserDataSourceUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserDataSourceUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserDataSourceUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> UserDataSourceUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserDataSourceUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2730,7 +2726,7 @@ impl<'a, C, NC, A> UserDataSourceUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &DataSource) -> UserDataSourceUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &DataSource) -> UserDataSourceUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2740,7 +2736,7 @@ impl<'a, C, NC, A> UserDataSourceUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Update the data source for the person identified. Use me to indicate the authenticated user. Only me is supported at this time. - pub fn user_id(mut self, new_value: &str) -> UserDataSourceUpdateCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserDataSourceUpdateCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -2750,7 +2746,7 @@ impl<'a, C, NC, A> UserDataSourceUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The data stream ID of the data source to update. - pub fn data_source_id(mut self, new_value: &str) -> UserDataSourceUpdateCall<'a, C, NC, A> { + pub fn data_source_id(mut self, new_value: &str) -> UserDataSourceUpdateCall<'a, C, A> { self._data_source_id = new_value.to_string(); self } @@ -2761,7 +2757,7 @@ impl<'a, C, NC, A> UserDataSourceUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDataSourceUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDataSourceUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2782,7 +2778,7 @@ impl<'a, C, NC, A> UserDataSourceUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserDataSourceUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserDataSourceUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2799,7 +2795,7 @@ impl<'a, C, NC, A> UserDataSourceUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserDataSourceUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserDataSourceUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2841,10 +2837,10 @@ impl<'a, C, NC, A> UserDataSourceUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct UserSessionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserSessionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fitness, + hub: &'a Fitness, _user_id: String, _start_time: Option, _page_token: Option, @@ -2855,9 +2851,9 @@ pub struct UserSessionListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserSessionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserSessionListCall<'a, C, A> {} -impl<'a, C, NC, A> UserSessionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserSessionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3001,7 +2997,7 @@ impl<'a, C, NC, A> UserSessionListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// List sessions for the person identified. Use me to indicate the authenticated user. Only me is supported at this time. - pub fn user_id(mut self, new_value: &str) -> UserSessionListCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserSessionListCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -3009,7 +3005,7 @@ impl<'a, C, NC, A> UserSessionListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// An RFC3339 timestamp. Only sessions ending between the start and end times will be included in the response. - pub fn start_time(mut self, new_value: &str) -> UserSessionListCall<'a, C, NC, A> { + pub fn start_time(mut self, new_value: &str) -> UserSessionListCall<'a, C, A> { self._start_time = Some(new_value.to_string()); self } @@ -3017,7 +3013,7 @@ impl<'a, C, NC, A> UserSessionListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The continuation token, which is used to page through large result sets. To get the next page of results, set this parameter to the value of nextPageToken from the previous response. - pub fn page_token(mut self, new_value: &str) -> UserSessionListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> UserSessionListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -3025,7 +3021,7 @@ impl<'a, C, NC, A> UserSessionListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// If true, deleted sessions will be returned. When set to true, sessions returned in this response will only have an ID and will not have any other fields. - pub fn include_deleted(mut self, new_value: bool) -> UserSessionListCall<'a, C, NC, A> { + pub fn include_deleted(mut self, new_value: bool) -> UserSessionListCall<'a, C, A> { self._include_deleted = Some(new_value); self } @@ -3033,7 +3029,7 @@ impl<'a, C, NC, A> UserSessionListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// An RFC3339 timestamp. Only sessions ending between the start and end times will be included in the response. - pub fn end_time(mut self, new_value: &str) -> UserSessionListCall<'a, C, NC, A> { + pub fn end_time(mut self, new_value: &str) -> UserSessionListCall<'a, C, A> { self._end_time = Some(new_value.to_string()); self } @@ -3044,7 +3040,7 @@ impl<'a, C, NC, A> UserSessionListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserSessionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserSessionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3065,7 +3061,7 @@ impl<'a, C, NC, A> UserSessionListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserSessionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserSessionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3082,7 +3078,7 @@ impl<'a, C, NC, A> UserSessionListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserSessionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserSessionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3127,10 +3123,10 @@ impl<'a, C, NC, A> UserSessionListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct UserSessionUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserSessionUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fitness, + hub: &'a Fitness, _request: Session, _user_id: String, _session_id: String, @@ -3140,9 +3136,9 @@ pub struct UserSessionUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserSessionUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserSessionUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> UserSessionUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserSessionUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3285,7 +3281,7 @@ impl<'a, C, NC, A> UserSessionUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Session) -> UserSessionUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Session) -> UserSessionUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3295,7 +3291,7 @@ impl<'a, C, NC, A> UserSessionUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Create sessions for the person identified. Use me to indicate the authenticated user. Only me is supported at this time. - pub fn user_id(mut self, new_value: &str) -> UserSessionUpdateCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserSessionUpdateCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -3305,7 +3301,7 @@ impl<'a, C, NC, A> UserSessionUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the session to be created. - pub fn session_id(mut self, new_value: &str) -> UserSessionUpdateCall<'a, C, NC, A> { + pub fn session_id(mut self, new_value: &str) -> UserSessionUpdateCall<'a, C, A> { self._session_id = new_value.to_string(); self } @@ -3313,7 +3309,7 @@ impl<'a, C, NC, A> UserSessionUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The client's current time in milliseconds since epoch. - pub fn current_time_millis(mut self, new_value: &str) -> UserSessionUpdateCall<'a, C, NC, A> { + pub fn current_time_millis(mut self, new_value: &str) -> UserSessionUpdateCall<'a, C, A> { self._current_time_millis = Some(new_value.to_string()); self } @@ -3324,7 +3320,7 @@ impl<'a, C, NC, A> UserSessionUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserSessionUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserSessionUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3345,7 +3341,7 @@ impl<'a, C, NC, A> UserSessionUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserSessionUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserSessionUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3362,7 +3358,7 @@ impl<'a, C, NC, A> UserSessionUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserSessionUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserSessionUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3408,10 +3404,10 @@ impl<'a, C, NC, A> UserSessionUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct UserDataSourcePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserDataSourcePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fitness, + hub: &'a Fitness, _request: DataSource, _user_id: String, _data_source_id: String, @@ -3420,9 +3416,9 @@ pub struct UserDataSourcePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserDataSourcePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserDataSourcePatchCall<'a, C, A> {} -impl<'a, C, NC, A> UserDataSourcePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserDataSourcePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3562,7 +3558,7 @@ impl<'a, C, NC, A> UserDataSourcePatchCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &DataSource) -> UserDataSourcePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &DataSource) -> UserDataSourcePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3572,7 +3568,7 @@ impl<'a, C, NC, A> UserDataSourcePatchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Update the data source for the person identified. Use me to indicate the authenticated user. Only me is supported at this time. - pub fn user_id(mut self, new_value: &str) -> UserDataSourcePatchCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserDataSourcePatchCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -3582,7 +3578,7 @@ impl<'a, C, NC, A> UserDataSourcePatchCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The data stream ID of the data source to update. - pub fn data_source_id(mut self, new_value: &str) -> UserDataSourcePatchCall<'a, C, NC, A> { + pub fn data_source_id(mut self, new_value: &str) -> UserDataSourcePatchCall<'a, C, A> { self._data_source_id = new_value.to_string(); self } @@ -3593,7 +3589,7 @@ impl<'a, C, NC, A> UserDataSourcePatchCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDataSourcePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDataSourcePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3614,7 +3610,7 @@ impl<'a, C, NC, A> UserDataSourcePatchCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserDataSourcePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserDataSourcePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3631,7 +3627,7 @@ impl<'a, C, NC, A> UserDataSourcePatchCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserDataSourcePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserDataSourcePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3670,10 +3666,10 @@ impl<'a, C, NC, A> UserDataSourcePatchCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct UserDataSourceListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserDataSourceListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fitness, + hub: &'a Fitness, _user_id: String, _data_type_name: Vec, _delegate: Option<&'a mut Delegate>, @@ -3681,9 +3677,9 @@ pub struct UserDataSourceListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserDataSourceListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserDataSourceListCall<'a, C, A> {} -impl<'a, C, NC, A> UserDataSourceListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserDataSourceListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3822,7 +3818,7 @@ impl<'a, C, NC, A> UserDataSourceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// List data sources for the person identified. Use me to indicate the authenticated user. Only me is supported at this time. - pub fn user_id(mut self, new_value: &str) -> UserDataSourceListCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserDataSourceListCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -3831,7 +3827,7 @@ impl<'a, C, NC, A> UserDataSourceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// The names of data types to include in the list. If not specified, all data sources will be returned. - pub fn add_data_type_name(mut self, new_value: &str) -> UserDataSourceListCall<'a, C, NC, A> { + pub fn add_data_type_name(mut self, new_value: &str) -> UserDataSourceListCall<'a, C, A> { self._data_type_name.push(new_value.to_string()); self } @@ -3842,7 +3838,7 @@ impl<'a, C, NC, A> UserDataSourceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDataSourceListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDataSourceListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3863,7 +3859,7 @@ impl<'a, C, NC, A> UserDataSourceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserDataSourceListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserDataSourceListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3880,7 +3876,7 @@ impl<'a, C, NC, A> UserDataSourceListCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserDataSourceListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserDataSourceListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/freebase1/Cargo.toml b/gen/freebase1/Cargo.toml index 4cf284f4c95..61283f82357 100644 --- a/gen/freebase1/Cargo.toml +++ b/gen/freebase1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-freebase1" -version = "0.1.4+20150330" +version = "0.1.5+20150330" authors = ["Sebastian Thiel "] description = "A complete library to interact with freebase (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/freebase1" homepage = "https://developers.google.com/freebase/" -documentation = "http://byron.github.io/google-apis-rs/google-freebase1" +documentation = "http://byron.github.io/google-apis-rs/google_freebase1" license = "MIT" keywords = ["freebase", "google", "protocol", "web", "api"] diff --git a/gen/freebase1/README.md b/gen/freebase1/README.md index 2422c336e6d..70a023da51a 100644 --- a/gen/freebase1/README.md +++ b/gen/freebase1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-freebase1` library allows access to all features of the *Google freebase* service. -This documentation was generated from *freebase* crate version *0.1.4+20150330*, where *20150330* is the exact revision of the *freebase:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *freebase* crate version *0.1.5+20150330*, where *20150330* is the exact revision of the *freebase:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *freebase* *v1* API can be found at the [official documentation site](https://developers.google.com/freebase/). diff --git a/gen/freebase1/src/cmn.rs b/gen/freebase1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/freebase1/src/cmn.rs +++ b/gen/freebase1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/freebase1/src/lib.rs b/gen/freebase1/src/lib.rs index a300398d152..d5aab071edf 100644 --- a/gen/freebase1/src/lib.rs +++ b/gen/freebase1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *freebase* crate version *0.1.4+20150330*, where *20150330* is the exact revision of the *freebase:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *freebase* crate version *0.1.5+20150330*, where *20150330* is the exact revision of the *freebase:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *freebase* *v1* API can be found at the //! [official documentation site](https://developers.google.com/freebase/). @@ -198,7 +198,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -273,34 +272,31 @@ pub use cmn::{MultiPartReader, ToParts, MethodInfo, Result, Error, CallBuilder, /// } /// # } /// ``` -pub struct Freebase { +pub struct Freebase { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Freebase {} +impl<'a, C, A> Hub for Freebase {} -impl<'a, C, NC, A> Freebase - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Freebase + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Freebase { + pub fn new(client: C, authenticator: A) -> Freebase { Freebase { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn methods(&'a self) -> MethodMethods<'a, C, NC, A> { + pub fn methods(&'a self) -> MethodMethods<'a, C, A> { MethodMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -443,20 +439,20 @@ impl Part for ReconcileCandidateNotable {} /// let rb = hub.methods(); /// # } /// ``` -pub struct MethodMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MethodMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Freebase, + hub: &'a Freebase, } -impl<'a, C, NC, A> MethodsBuilder for MethodMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for MethodMethods<'a, C, A> {} -impl<'a, C, NC, A> MethodMethods<'a, C, NC, A> { +impl<'a, C, A> MethodMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Reconcile entities to Freebase open data. - pub fn reconcile(&self) -> MethodReconcileCall<'a, C, NC, A> { + pub fn reconcile(&self) -> MethodReconcileCall<'a, C, A> { MethodReconcileCall { hub: self.hub, _prop: Default::default(), @@ -473,7 +469,7 @@ impl<'a, C, NC, A> MethodMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Search Freebase open data. - pub fn search(&self) -> MethodSearchCall<'a, C, NC, A> { + pub fn search(&self) -> MethodSearchCall<'a, C, A> { MethodSearchCall { hub: self.hub, _without: Default::default(), @@ -549,10 +545,10 @@ impl<'a, C, NC, A> MethodMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct MethodReconcileCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MethodReconcileCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Freebase, + hub: &'a Freebase, _prop: Vec, _name: Option, _limit: Option, @@ -563,9 +559,9 @@ pub struct MethodReconcileCall<'a, C, NC, A> _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for MethodReconcileCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MethodReconcileCall<'a, C, A> {} -impl<'a, C, NC, A> MethodReconcileCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MethodReconcileCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -700,7 +696,7 @@ impl<'a, C, NC, A> MethodReconcileCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// Property values for entity formatted as /// : - pub fn add_prop(mut self, new_value: &str) -> MethodReconcileCall<'a, C, NC, A> { + pub fn add_prop(mut self, new_value: &str) -> MethodReconcileCall<'a, C, A> { self._prop.push(new_value.to_string()); self } @@ -708,7 +704,7 @@ impl<'a, C, NC, A> MethodReconcileCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Name of entity. - pub fn name(mut self, new_value: &str) -> MethodReconcileCall<'a, C, NC, A> { + pub fn name(mut self, new_value: &str) -> MethodReconcileCall<'a, C, A> { self._name = Some(new_value.to_string()); self } @@ -716,7 +712,7 @@ impl<'a, C, NC, A> MethodReconcileCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Maximum number of candidates to return. - pub fn limit(mut self, new_value: i32) -> MethodReconcileCall<'a, C, NC, A> { + pub fn limit(mut self, new_value: i32) -> MethodReconcileCall<'a, C, A> { self._limit = Some(new_value); self } @@ -725,7 +721,7 @@ impl<'a, C, NC, A> MethodReconcileCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Languages for names and values. First language is used for display. Default is 'en'. - pub fn add_lang(mut self, new_value: &str) -> MethodReconcileCall<'a, C, NC, A> { + pub fn add_lang(mut self, new_value: &str) -> MethodReconcileCall<'a, C, A> { self._lang.push(new_value.to_string()); self } @@ -734,7 +730,7 @@ impl<'a, C, NC, A> MethodReconcileCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Classifications of entity e.g. type, category, title. - pub fn add_kind(mut self, new_value: &str) -> MethodReconcileCall<'a, C, NC, A> { + pub fn add_kind(mut self, new_value: &str) -> MethodReconcileCall<'a, C, A> { self._kind.push(new_value.to_string()); self } @@ -742,7 +738,7 @@ impl<'a, C, NC, A> MethodReconcileCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Required confidence for a candidate to match. Must be between .5 and 1.0 - pub fn confidence(mut self, new_value: f32) -> MethodReconcileCall<'a, C, NC, A> { + pub fn confidence(mut self, new_value: f32) -> MethodReconcileCall<'a, C, A> { self._confidence = Some(new_value); self } @@ -753,7 +749,7 @@ impl<'a, C, NC, A> MethodReconcileCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MethodReconcileCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MethodReconcileCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -774,7 +770,7 @@ impl<'a, C, NC, A> MethodReconcileCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MethodReconcileCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MethodReconcileCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -839,10 +835,10 @@ impl<'a, C, NC, A> MethodReconcileCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct MethodSearchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MethodSearchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Freebase, + hub: &'a Freebase, _without: Vec, _with: Vec, _type_: Vec, @@ -870,9 +866,9 @@ pub struct MethodSearchCall<'a, C, NC, A> _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for MethodSearchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MethodSearchCall<'a, C, A> {} -impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MethodSearchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1062,7 +1058,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// A rule to not match against. - pub fn add_without(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn add_without(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._without.push(new_value.to_string()); self } @@ -1071,7 +1067,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// A rule to match against. - pub fn add_with(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn add_with(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._with.push(new_value.to_string()); self } @@ -1080,7 +1076,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Restrict to topics with this Freebase type id. - pub fn add_type(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn add_type(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._type_.push(new_value.to_string()); self } @@ -1088,7 +1084,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Query on stemmed names and aliases. May not be used with prefixed. - pub fn stemmed(mut self, new_value: bool) -> MethodSearchCall<'a, C, NC, A> { + pub fn stemmed(mut self, new_value: bool) -> MethodSearchCall<'a, C, A> { self._stemmed = Some(new_value); self } @@ -1096,7 +1092,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Request 'did you mean' suggestions - pub fn spell(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn spell(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._spell = Some(new_value.to_string()); self } @@ -1104,7 +1100,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Relevance scoring algorithm to use. - pub fn scoring(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn scoring(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._scoring = Some(new_value.to_string()); self } @@ -1112,7 +1108,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Query term to search for. - pub fn query(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn query(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._query = Some(new_value.to_string()); self } @@ -1120,7 +1116,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Prefix match against names and aliases. - pub fn prefixed(mut self, new_value: bool) -> MethodSearchCall<'a, C, NC, A> { + pub fn prefixed(mut self, new_value: bool) -> MethodSearchCall<'a, C, A> { self._prefixed = Some(new_value); self } @@ -1128,7 +1124,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// An output expression to request data from matches. - pub fn output(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn output(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._output = Some(new_value.to_string()); self } @@ -1136,7 +1132,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The MQL query to run againist the results to extract more data. - pub fn mql_output(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn mql_output(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._mql_output = Some(new_value.to_string()); self } @@ -1145,7 +1141,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// A mid to use instead of a query. - pub fn add_mid(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn add_mid(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._mid.push(new_value.to_string()); self } @@ -1153,7 +1149,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Maximum number of results to return. - pub fn limit(mut self, new_value: i32) -> MethodSearchCall<'a, C, NC, A> { + pub fn limit(mut self, new_value: i32) -> MethodSearchCall<'a, C, A> { self._limit = Some(new_value); self } @@ -1162,7 +1158,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The code of the language to run the query with. Default is 'en'. - pub fn add_lang(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn add_lang(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._lang.push(new_value.to_string()); self } @@ -1170,7 +1166,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Whether to indent the json results or not. - pub fn indent(mut self, new_value: bool) -> MethodSearchCall<'a, C, NC, A> { + pub fn indent(mut self, new_value: bool) -> MethodSearchCall<'a, C, A> { self._indent = Some(new_value); self } @@ -1178,7 +1174,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The keyword to request help on. - pub fn help(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn help(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._help = Some(new_value.to_string()); self } @@ -1186,7 +1182,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Structural format of the json response. - pub fn format(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn format(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._format = Some(new_value.to_string()); self } @@ -1195,7 +1191,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// A filter to apply to the query. - pub fn add_filter(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn add_filter(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._filter.push(new_value.to_string()); self } @@ -1203,7 +1199,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Query on exact name and keys only. - pub fn exact(mut self, new_value: bool) -> MethodSearchCall<'a, C, NC, A> { + pub fn exact(mut self, new_value: bool) -> MethodSearchCall<'a, C, A> { self._exact = Some(new_value); self } @@ -1211,7 +1207,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The encoding of the response. You can use this parameter to enable html encoding. - pub fn encode(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn encode(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._encode = Some(new_value.to_string()); self } @@ -1220,7 +1216,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Restrict to topics with this Freebase domain id. - pub fn add_domain(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn add_domain(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._domain.push(new_value.to_string()); self } @@ -1228,7 +1224,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The cursor value to use for the next page of results. - pub fn cursor(mut self, new_value: i32) -> MethodSearchCall<'a, C, NC, A> { + pub fn cursor(mut self, new_value: i32) -> MethodSearchCall<'a, C, A> { self._cursor = Some(new_value); self } @@ -1236,7 +1232,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// JS method name for JSONP callbacks. - pub fn callback(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn callback(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._callback = Some(new_value.to_string()); self } @@ -1244,7 +1240,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// A mql as_of_time value to use with mql_output queries. - pub fn as_of_time(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn as_of_time(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._as_of_time = Some(new_value.to_string()); self } @@ -1255,7 +1251,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MethodSearchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MethodSearchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1276,7 +1272,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MethodSearchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MethodSearchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self diff --git a/gen/freebase1_sandbox/Cargo.toml b/gen/freebase1_sandbox/Cargo.toml index a782490a13b..8ac18fd35cc 100644 --- a/gen/freebase1_sandbox/Cargo.toml +++ b/gen/freebase1_sandbox/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-freebase1_sandbox" -version = "0.1.4+20150330" +version = "0.1.5+20150330" authors = ["Sebastian Thiel "] description = "A complete library to interact with freebase (protocol v1sandbox)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/freebase1_sandbox" homepage = "https://developers.google.com/freebase/" -documentation = "http://byron.github.io/google-apis-rs/google-freebase1_sandbox" +documentation = "http://byron.github.io/google-apis-rs/google_freebase1_sandbox" license = "MIT" keywords = ["freebase", "google", "protocol", "web", "api"] diff --git a/gen/freebase1_sandbox/README.md b/gen/freebase1_sandbox/README.md index ee6685195e1..4229cf9c72c 100644 --- a/gen/freebase1_sandbox/README.md +++ b/gen/freebase1_sandbox/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-freebase1_sandbox` library allows access to all features of the *Google freebase* service. -This documentation was generated from *freebase* crate version *0.1.4+20150330*, where *20150330* is the exact revision of the *freebase:v1sandbox* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *freebase* crate version *0.1.5+20150330*, where *20150330* is the exact revision of the *freebase:v1sandbox* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *freebase* *v1_sandbox* API can be found at the [official documentation site](https://developers.google.com/freebase/). diff --git a/gen/freebase1_sandbox/src/cmn.rs b/gen/freebase1_sandbox/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/freebase1_sandbox/src/cmn.rs +++ b/gen/freebase1_sandbox/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/freebase1_sandbox/src/lib.rs b/gen/freebase1_sandbox/src/lib.rs index de7e8942960..1b48cfa4489 100644 --- a/gen/freebase1_sandbox/src/lib.rs +++ b/gen/freebase1_sandbox/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *freebase* crate version *0.1.4+20150330*, where *20150330* is the exact revision of the *freebase:v1sandbox* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *freebase* crate version *0.1.5+20150330*, where *20150330* is the exact revision of the *freebase:v1sandbox* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *freebase* *v1_sandbox* API can be found at the //! [official documentation site](https://developers.google.com/freebase/). @@ -198,7 +198,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -273,34 +272,31 @@ pub use cmn::{MultiPartReader, ToParts, MethodInfo, Result, Error, CallBuilder, /// } /// # } /// ``` -pub struct Freebase { +pub struct Freebase { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Freebase {} +impl<'a, C, A> Hub for Freebase {} -impl<'a, C, NC, A> Freebase - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Freebase + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Freebase { + pub fn new(client: C, authenticator: A) -> Freebase { Freebase { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn methods(&'a self) -> MethodMethods<'a, C, NC, A> { + pub fn methods(&'a self) -> MethodMethods<'a, C, A> { MethodMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -443,20 +439,20 @@ impl Part for ReconcileCandidateNotable {} /// let rb = hub.methods(); /// # } /// ``` -pub struct MethodMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MethodMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Freebase, + hub: &'a Freebase, } -impl<'a, C, NC, A> MethodsBuilder for MethodMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for MethodMethods<'a, C, A> {} -impl<'a, C, NC, A> MethodMethods<'a, C, NC, A> { +impl<'a, C, A> MethodMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Reconcile entities to Freebase open data. - pub fn reconcile(&self) -> MethodReconcileCall<'a, C, NC, A> { + pub fn reconcile(&self) -> MethodReconcileCall<'a, C, A> { MethodReconcileCall { hub: self.hub, _prop: Default::default(), @@ -473,7 +469,7 @@ impl<'a, C, NC, A> MethodMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Search Freebase open data. - pub fn search(&self) -> MethodSearchCall<'a, C, NC, A> { + pub fn search(&self) -> MethodSearchCall<'a, C, A> { MethodSearchCall { hub: self.hub, _without: Default::default(), @@ -549,10 +545,10 @@ impl<'a, C, NC, A> MethodMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct MethodReconcileCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MethodReconcileCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Freebase, + hub: &'a Freebase, _prop: Vec, _name: Option, _limit: Option, @@ -563,9 +559,9 @@ pub struct MethodReconcileCall<'a, C, NC, A> _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for MethodReconcileCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MethodReconcileCall<'a, C, A> {} -impl<'a, C, NC, A> MethodReconcileCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MethodReconcileCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -700,7 +696,7 @@ impl<'a, C, NC, A> MethodReconcileCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// Property values for entity formatted as /// : - pub fn add_prop(mut self, new_value: &str) -> MethodReconcileCall<'a, C, NC, A> { + pub fn add_prop(mut self, new_value: &str) -> MethodReconcileCall<'a, C, A> { self._prop.push(new_value.to_string()); self } @@ -708,7 +704,7 @@ impl<'a, C, NC, A> MethodReconcileCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Name of entity. - pub fn name(mut self, new_value: &str) -> MethodReconcileCall<'a, C, NC, A> { + pub fn name(mut self, new_value: &str) -> MethodReconcileCall<'a, C, A> { self._name = Some(new_value.to_string()); self } @@ -716,7 +712,7 @@ impl<'a, C, NC, A> MethodReconcileCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Maximum number of candidates to return. - pub fn limit(mut self, new_value: i32) -> MethodReconcileCall<'a, C, NC, A> { + pub fn limit(mut self, new_value: i32) -> MethodReconcileCall<'a, C, A> { self._limit = Some(new_value); self } @@ -725,7 +721,7 @@ impl<'a, C, NC, A> MethodReconcileCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Languages for names and values. First language is used for display. Default is 'en'. - pub fn add_lang(mut self, new_value: &str) -> MethodReconcileCall<'a, C, NC, A> { + pub fn add_lang(mut self, new_value: &str) -> MethodReconcileCall<'a, C, A> { self._lang.push(new_value.to_string()); self } @@ -734,7 +730,7 @@ impl<'a, C, NC, A> MethodReconcileCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Classifications of entity e.g. type, category, title. - pub fn add_kind(mut self, new_value: &str) -> MethodReconcileCall<'a, C, NC, A> { + pub fn add_kind(mut self, new_value: &str) -> MethodReconcileCall<'a, C, A> { self._kind.push(new_value.to_string()); self } @@ -742,7 +738,7 @@ impl<'a, C, NC, A> MethodReconcileCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Required confidence for a candidate to match. Must be between .5 and 1.0 - pub fn confidence(mut self, new_value: f32) -> MethodReconcileCall<'a, C, NC, A> { + pub fn confidence(mut self, new_value: f32) -> MethodReconcileCall<'a, C, A> { self._confidence = Some(new_value); self } @@ -753,7 +749,7 @@ impl<'a, C, NC, A> MethodReconcileCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MethodReconcileCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MethodReconcileCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -774,7 +770,7 @@ impl<'a, C, NC, A> MethodReconcileCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MethodReconcileCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MethodReconcileCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -839,10 +835,10 @@ impl<'a, C, NC, A> MethodReconcileCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct MethodSearchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MethodSearchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Freebase, + hub: &'a Freebase, _without: Vec, _with: Vec, _type_: Vec, @@ -870,9 +866,9 @@ pub struct MethodSearchCall<'a, C, NC, A> _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for MethodSearchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MethodSearchCall<'a, C, A> {} -impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MethodSearchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1062,7 +1058,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// A rule to not match against. - pub fn add_without(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn add_without(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._without.push(new_value.to_string()); self } @@ -1071,7 +1067,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// A rule to match against. - pub fn add_with(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn add_with(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._with.push(new_value.to_string()); self } @@ -1080,7 +1076,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Restrict to topics with this Freebase type id. - pub fn add_type(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn add_type(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._type_.push(new_value.to_string()); self } @@ -1088,7 +1084,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Query on stemmed names and aliases. May not be used with prefixed. - pub fn stemmed(mut self, new_value: bool) -> MethodSearchCall<'a, C, NC, A> { + pub fn stemmed(mut self, new_value: bool) -> MethodSearchCall<'a, C, A> { self._stemmed = Some(new_value); self } @@ -1096,7 +1092,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Request 'did you mean' suggestions - pub fn spell(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn spell(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._spell = Some(new_value.to_string()); self } @@ -1104,7 +1100,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Relevance scoring algorithm to use. - pub fn scoring(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn scoring(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._scoring = Some(new_value.to_string()); self } @@ -1112,7 +1108,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Query term to search for. - pub fn query(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn query(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._query = Some(new_value.to_string()); self } @@ -1120,7 +1116,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Prefix match against names and aliases. - pub fn prefixed(mut self, new_value: bool) -> MethodSearchCall<'a, C, NC, A> { + pub fn prefixed(mut self, new_value: bool) -> MethodSearchCall<'a, C, A> { self._prefixed = Some(new_value); self } @@ -1128,7 +1124,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// An output expression to request data from matches. - pub fn output(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn output(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._output = Some(new_value.to_string()); self } @@ -1136,7 +1132,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The MQL query to run againist the results to extract more data. - pub fn mql_output(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn mql_output(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._mql_output = Some(new_value.to_string()); self } @@ -1145,7 +1141,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// A mid to use instead of a query. - pub fn add_mid(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn add_mid(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._mid.push(new_value.to_string()); self } @@ -1153,7 +1149,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Maximum number of results to return. - pub fn limit(mut self, new_value: i32) -> MethodSearchCall<'a, C, NC, A> { + pub fn limit(mut self, new_value: i32) -> MethodSearchCall<'a, C, A> { self._limit = Some(new_value); self } @@ -1162,7 +1158,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The code of the language to run the query with. Default is 'en'. - pub fn add_lang(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn add_lang(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._lang.push(new_value.to_string()); self } @@ -1170,7 +1166,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Whether to indent the json results or not. - pub fn indent(mut self, new_value: bool) -> MethodSearchCall<'a, C, NC, A> { + pub fn indent(mut self, new_value: bool) -> MethodSearchCall<'a, C, A> { self._indent = Some(new_value); self } @@ -1178,7 +1174,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The keyword to request help on. - pub fn help(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn help(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._help = Some(new_value.to_string()); self } @@ -1186,7 +1182,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Structural format of the json response. - pub fn format(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn format(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._format = Some(new_value.to_string()); self } @@ -1195,7 +1191,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// A filter to apply to the query. - pub fn add_filter(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn add_filter(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._filter.push(new_value.to_string()); self } @@ -1203,7 +1199,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Query on exact name and keys only. - pub fn exact(mut self, new_value: bool) -> MethodSearchCall<'a, C, NC, A> { + pub fn exact(mut self, new_value: bool) -> MethodSearchCall<'a, C, A> { self._exact = Some(new_value); self } @@ -1211,7 +1207,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The encoding of the response. You can use this parameter to enable html encoding. - pub fn encode(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn encode(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._encode = Some(new_value.to_string()); self } @@ -1220,7 +1216,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Restrict to topics with this Freebase domain id. - pub fn add_domain(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn add_domain(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._domain.push(new_value.to_string()); self } @@ -1228,7 +1224,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The cursor value to use for the next page of results. - pub fn cursor(mut self, new_value: i32) -> MethodSearchCall<'a, C, NC, A> { + pub fn cursor(mut self, new_value: i32) -> MethodSearchCall<'a, C, A> { self._cursor = Some(new_value); self } @@ -1236,7 +1232,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// JS method name for JSONP callbacks. - pub fn callback(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn callback(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._callback = Some(new_value.to_string()); self } @@ -1244,7 +1240,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// A mql as_of_time value to use with mql_output queries. - pub fn as_of_time(mut self, new_value: &str) -> MethodSearchCall<'a, C, NC, A> { + pub fn as_of_time(mut self, new_value: &str) -> MethodSearchCall<'a, C, A> { self._as_of_time = Some(new_value.to_string()); self } @@ -1255,7 +1251,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MethodSearchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MethodSearchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1276,7 +1272,7 @@ impl<'a, C, NC, A> MethodSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MethodSearchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MethodSearchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self diff --git a/gen/fusiontables2/Cargo.toml b/gen/fusiontables2/Cargo.toml index f1c81b534a4..ae66420b631 100644 --- a/gen/fusiontables2/Cargo.toml +++ b/gen/fusiontables2/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-fusiontables2" -version = "0.1.4+20150226" +version = "0.1.5+20150226" authors = ["Sebastian Thiel "] description = "A complete library to interact with fusiontables (protocol v2)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/fusiontables2" homepage = "https://developers.google.com/fusiontables" -documentation = "http://byron.github.io/google-apis-rs/google-fusiontables2" +documentation = "http://byron.github.io/google-apis-rs/google_fusiontables2" license = "MIT" keywords = ["fusiontables", "google", "protocol", "web", "api"] diff --git a/gen/fusiontables2/README.md b/gen/fusiontables2/README.md index 5335da37dc3..9b9c00fae6e 100644 --- a/gen/fusiontables2/README.md +++ b/gen/fusiontables2/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-fusiontables2` library allows access to all features of the *Google fusiontables* service. -This documentation was generated from *fusiontables* crate version *0.1.4+20150226*, where *20150226* is the exact revision of the *fusiontables:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *fusiontables* crate version *0.1.5+20150226*, where *20150226* is the exact revision of the *fusiontables:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *fusiontables* *v2* API can be found at the [official documentation site](https://developers.google.com/fusiontables). diff --git a/gen/fusiontables2/src/cmn.rs b/gen/fusiontables2/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/fusiontables2/src/cmn.rs +++ b/gen/fusiontables2/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/fusiontables2/src/lib.rs b/gen/fusiontables2/src/lib.rs index 3f9e7518cd7..2fc1fdda653 100644 --- a/gen/fusiontables2/src/lib.rs +++ b/gen/fusiontables2/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *fusiontables* crate version *0.1.4+20150226*, where *20150226* is the exact revision of the *fusiontables:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *fusiontables* crate version *0.1.5+20150226*, where *20150226* is the exact revision of the *fusiontables:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *fusiontables* *v2* API can be found at the //! [official documentation site](https://developers.google.com/fusiontables). @@ -217,7 +217,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -315,49 +314,46 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Fusiontables { +pub struct Fusiontables { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Fusiontables {} +impl<'a, C, A> Hub for Fusiontables {} -impl<'a, C, NC, A> Fusiontables - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Fusiontables + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Fusiontables { + pub fn new(client: C, authenticator: A) -> Fusiontables { Fusiontables { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn column(&'a self) -> ColumnMethods<'a, C, NC, A> { + pub fn column(&'a self) -> ColumnMethods<'a, C, A> { ColumnMethods { hub: &self } } - pub fn query(&'a self) -> QueryMethods<'a, C, NC, A> { + pub fn query(&'a self) -> QueryMethods<'a, C, A> { QueryMethods { hub: &self } } - pub fn style(&'a self) -> StyleMethods<'a, C, NC, A> { + pub fn style(&'a self) -> StyleMethods<'a, C, A> { StyleMethods { hub: &self } } - pub fn table(&'a self) -> TableMethods<'a, C, NC, A> { + pub fn table(&'a self) -> TableMethods<'a, C, A> { TableMethods { hub: &self } } - pub fn task(&'a self) -> TaskMethods<'a, C, NC, A> { + pub fn task(&'a self) -> TaskMethods<'a, C, A> { TaskMethods { hub: &self } } - pub fn template(&'a self) -> TemplateMethods<'a, C, NC, A> { + pub fn template(&'a self) -> TemplateMethods<'a, C, A> { TemplateMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -962,15 +958,15 @@ impl Part for StyleFunctionGradientColors {} /// let rb = hub.style(); /// # } /// ``` -pub struct StyleMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct StyleMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, } -impl<'a, C, NC, A> MethodsBuilder for StyleMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for StyleMethods<'a, C, A> {} -impl<'a, C, NC, A> StyleMethods<'a, C, NC, A> { +impl<'a, C, A> StyleMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -979,7 +975,7 @@ impl<'a, C, NC, A> StyleMethods<'a, C, NC, A> { /// # Arguments /// /// * `tableId` - Table whose styles are being listed - pub fn list(&self, table_id: &str) -> StyleListCall<'a, C, NC, A> { + pub fn list(&self, table_id: &str) -> StyleListCall<'a, C, A> { StyleListCall { hub: self.hub, _table_id: table_id.to_string(), @@ -1000,7 +996,7 @@ impl<'a, C, NC, A> StyleMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `tableId` - Table whose style is being updated. /// * `styleId` - Identifier (within a table) for the style being updated. - pub fn update(&self, request: &StyleSetting, table_id: &str, style_id: i32) -> StyleUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &StyleSetting, table_id: &str, style_id: i32) -> StyleUpdateCall<'a, C, A> { StyleUpdateCall { hub: self.hub, _request: request.clone(), @@ -1020,7 +1016,7 @@ impl<'a, C, NC, A> StyleMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `tableId` - Table for which a new style is being added - pub fn insert(&self, request: &StyleSetting, table_id: &str) -> StyleInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &StyleSetting, table_id: &str) -> StyleInsertCall<'a, C, A> { StyleInsertCall { hub: self.hub, _request: request.clone(), @@ -1039,7 +1035,7 @@ impl<'a, C, NC, A> StyleMethods<'a, C, NC, A> { /// /// * `tableId` - Table to which the requested style belongs /// * `styleId` - Identifier (integer) for a specific style in a table - pub fn get(&self, table_id: &str, style_id: i32) -> StyleGetCall<'a, C, NC, A> { + pub fn get(&self, table_id: &str, style_id: i32) -> StyleGetCall<'a, C, A> { StyleGetCall { hub: self.hub, _table_id: table_id.to_string(), @@ -1058,7 +1054,7 @@ impl<'a, C, NC, A> StyleMethods<'a, C, NC, A> { /// /// * `tableId` - Table from which the style is being deleted /// * `styleId` - Identifier (within a table) for the style being deleted - pub fn delete(&self, table_id: &str, style_id: i32) -> StyleDeleteCall<'a, C, NC, A> { + pub fn delete(&self, table_id: &str, style_id: i32) -> StyleDeleteCall<'a, C, A> { StyleDeleteCall { hub: self.hub, _table_id: table_id.to_string(), @@ -1078,7 +1074,7 @@ impl<'a, C, NC, A> StyleMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `tableId` - Table whose style is being updated. /// * `styleId` - Identifier (within a table) for the style being updated. - pub fn patch(&self, request: &StyleSetting, table_id: &str, style_id: i32) -> StylePatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &StyleSetting, table_id: &str, style_id: i32) -> StylePatchCall<'a, C, A> { StylePatchCall { hub: self.hub, _request: request.clone(), @@ -1121,15 +1117,15 @@ impl<'a, C, NC, A> StyleMethods<'a, C, NC, A> { /// let rb = hub.task(); /// # } /// ``` -pub struct TaskMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TaskMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, } -impl<'a, C, NC, A> MethodsBuilder for TaskMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TaskMethods<'a, C, A> {} -impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { +impl<'a, C, A> TaskMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1138,7 +1134,7 @@ impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { /// # Arguments /// /// * `tableId` - Table whose tasks are being listed. - pub fn list(&self, table_id: &str) -> TaskListCall<'a, C, NC, A> { + pub fn list(&self, table_id: &str) -> TaskListCall<'a, C, A> { TaskListCall { hub: self.hub, _table_id: table_id.to_string(), @@ -1159,7 +1155,7 @@ impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { /// /// * `tableId` - Table from which the task is being deleted. /// * `taskId` - The identifier of the task to delete. - pub fn delete(&self, table_id: &str, task_id: &str) -> TaskDeleteCall<'a, C, NC, A> { + pub fn delete(&self, table_id: &str, task_id: &str) -> TaskDeleteCall<'a, C, A> { TaskDeleteCall { hub: self.hub, _table_id: table_id.to_string(), @@ -1178,7 +1174,7 @@ impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { /// /// * `tableId` - Table to which the task belongs. /// * `taskId` - The identifier of the task to get. - pub fn get(&self, table_id: &str, task_id: &str) -> TaskGetCall<'a, C, NC, A> { + pub fn get(&self, table_id: &str, task_id: &str) -> TaskGetCall<'a, C, A> { TaskGetCall { hub: self.hub, _table_id: table_id.to_string(), @@ -1220,15 +1216,15 @@ impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { /// let rb = hub.column(); /// # } /// ``` -pub struct ColumnMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ColumnMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, } -impl<'a, C, NC, A> MethodsBuilder for ColumnMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ColumnMethods<'a, C, A> {} -impl<'a, C, NC, A> ColumnMethods<'a, C, NC, A> { +impl<'a, C, A> ColumnMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1238,7 +1234,7 @@ impl<'a, C, NC, A> ColumnMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `tableId` - Table for which a new column is being added. - pub fn insert(&self, request: &Column, table_id: &str) -> ColumnInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Column, table_id: &str) -> ColumnInsertCall<'a, C, A> { ColumnInsertCall { hub: self.hub, _request: request.clone(), @@ -1258,7 +1254,7 @@ impl<'a, C, NC, A> ColumnMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `tableId` - Table for which the column is being updated. /// * `columnId` - Name or identifier for the column that is being updated. - pub fn update(&self, request: &Column, table_id: &str, column_id: &str) -> ColumnUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Column, table_id: &str, column_id: &str) -> ColumnUpdateCall<'a, C, A> { ColumnUpdateCall { hub: self.hub, _request: request.clone(), @@ -1277,7 +1273,7 @@ impl<'a, C, NC, A> ColumnMethods<'a, C, NC, A> { /// # Arguments /// /// * `tableId` - Table whose columns are being listed. - pub fn list(&self, table_id: &str) -> ColumnListCall<'a, C, NC, A> { + pub fn list(&self, table_id: &str) -> ColumnListCall<'a, C, A> { ColumnListCall { hub: self.hub, _table_id: table_id.to_string(), @@ -1298,7 +1294,7 @@ impl<'a, C, NC, A> ColumnMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `tableId` - Table for which the column is being updated. /// * `columnId` - Name or identifier for the column that is being updated. - pub fn patch(&self, request: &Column, table_id: &str, column_id: &str) -> ColumnPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Column, table_id: &str, column_id: &str) -> ColumnPatchCall<'a, C, A> { ColumnPatchCall { hub: self.hub, _request: request.clone(), @@ -1318,7 +1314,7 @@ impl<'a, C, NC, A> ColumnMethods<'a, C, NC, A> { /// /// * `tableId` - Table from which the column is being deleted. /// * `columnId` - Name or identifier for the column being deleted. - pub fn delete(&self, table_id: &str, column_id: &str) -> ColumnDeleteCall<'a, C, NC, A> { + pub fn delete(&self, table_id: &str, column_id: &str) -> ColumnDeleteCall<'a, C, A> { ColumnDeleteCall { hub: self.hub, _table_id: table_id.to_string(), @@ -1337,7 +1333,7 @@ impl<'a, C, NC, A> ColumnMethods<'a, C, NC, A> { /// /// * `tableId` - Table to which the column belongs. /// * `columnId` - Name or identifier for the column that is being requested. - pub fn get(&self, table_id: &str, column_id: &str) -> ColumnGetCall<'a, C, NC, A> { + pub fn get(&self, table_id: &str, column_id: &str) -> ColumnGetCall<'a, C, A> { ColumnGetCall { hub: self.hub, _table_id: table_id.to_string(), @@ -1379,15 +1375,15 @@ impl<'a, C, NC, A> ColumnMethods<'a, C, NC, A> { /// let rb = hub.template(); /// # } /// ``` -pub struct TemplateMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TemplateMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, } -impl<'a, C, NC, A> MethodsBuilder for TemplateMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TemplateMethods<'a, C, A> {} -impl<'a, C, NC, A> TemplateMethods<'a, C, NC, A> { +impl<'a, C, A> TemplateMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1398,7 +1394,7 @@ impl<'a, C, NC, A> TemplateMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `tableId` - Table to which the updated template belongs /// * `templateId` - Identifier for the template that is being updated - pub fn update(&self, request: &Template, table_id: &str, template_id: i32) -> TemplateUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Template, table_id: &str, template_id: i32) -> TemplateUpdateCall<'a, C, A> { TemplateUpdateCall { hub: self.hub, _request: request.clone(), @@ -1417,7 +1413,7 @@ impl<'a, C, NC, A> TemplateMethods<'a, C, NC, A> { /// # Arguments /// /// * `tableId` - Identifier for the table whose templates are being requested - pub fn list(&self, table_id: &str) -> TemplateListCall<'a, C, NC, A> { + pub fn list(&self, table_id: &str) -> TemplateListCall<'a, C, A> { TemplateListCall { hub: self.hub, _table_id: table_id.to_string(), @@ -1437,7 +1433,7 @@ impl<'a, C, NC, A> TemplateMethods<'a, C, NC, A> { /// /// * `tableId` - Table from which the template is being deleted /// * `templateId` - Identifier for the template which is being deleted - pub fn delete(&self, table_id: &str, template_id: i32) -> TemplateDeleteCall<'a, C, NC, A> { + pub fn delete(&self, table_id: &str, template_id: i32) -> TemplateDeleteCall<'a, C, A> { TemplateDeleteCall { hub: self.hub, _table_id: table_id.to_string(), @@ -1456,7 +1452,7 @@ impl<'a, C, NC, A> TemplateMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `tableId` - Table for which a new template is being created - pub fn insert(&self, request: &Template, table_id: &str) -> TemplateInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Template, table_id: &str) -> TemplateInsertCall<'a, C, A> { TemplateInsertCall { hub: self.hub, _request: request.clone(), @@ -1476,7 +1472,7 @@ impl<'a, C, NC, A> TemplateMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `tableId` - Table to which the updated template belongs /// * `templateId` - Identifier for the template that is being updated - pub fn patch(&self, request: &Template, table_id: &str, template_id: i32) -> TemplatePatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Template, table_id: &str, template_id: i32) -> TemplatePatchCall<'a, C, A> { TemplatePatchCall { hub: self.hub, _request: request.clone(), @@ -1496,7 +1492,7 @@ impl<'a, C, NC, A> TemplateMethods<'a, C, NC, A> { /// /// * `tableId` - Table to which the template belongs /// * `templateId` - Identifier for the template that is being requested - pub fn get(&self, table_id: &str, template_id: i32) -> TemplateGetCall<'a, C, NC, A> { + pub fn get(&self, table_id: &str, template_id: i32) -> TemplateGetCall<'a, C, A> { TemplateGetCall { hub: self.hub, _table_id: table_id.to_string(), @@ -1538,15 +1534,15 @@ impl<'a, C, NC, A> TemplateMethods<'a, C, NC, A> { /// let rb = hub.query(); /// # } /// ``` -pub struct QueryMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct QueryMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, } -impl<'a, C, NC, A> MethodsBuilder for QueryMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for QueryMethods<'a, C, A> {} -impl<'a, C, NC, A> QueryMethods<'a, C, NC, A> { +impl<'a, C, A> QueryMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1561,7 +1557,7 @@ impl<'a, C, NC, A> QueryMethods<'a, C, NC, A> { /// - SELECT /// - SHOW /// - DESCRIBE - pub fn sql_get(&self, sql: &str) -> QuerySqlGetCall<'a, C, NC, A> { + pub fn sql_get(&self, sql: &str) -> QuerySqlGetCall<'a, C, A> { QuerySqlGetCall { hub: self.hub, _sql: sql.to_string(), @@ -1594,7 +1590,7 @@ impl<'a, C, NC, A> QueryMethods<'a, C, NC, A> { /// - SHOW /// - DESCRIBE /// - CREATE - pub fn sql(&self, sql: &str) -> QuerySqlCall<'a, C, NC, A> { + pub fn sql(&self, sql: &str) -> QuerySqlCall<'a, C, A> { QuerySqlCall { hub: self.hub, _sql: sql.to_string(), @@ -1637,15 +1633,15 @@ impl<'a, C, NC, A> QueryMethods<'a, C, NC, A> { /// let rb = hub.table(); /// # } /// ``` -pub struct TableMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, } -impl<'a, C, NC, A> MethodsBuilder for TableMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TableMethods<'a, C, A> {} -impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { +impl<'a, C, A> TableMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1655,7 +1651,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `tableId` - ID of the table that is being updated. - pub fn patch(&self, request: &Table, table_id: &str) -> TablePatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Table, table_id: &str) -> TablePatchCall<'a, C, A> { TablePatchCall { hub: self.hub, _request: request.clone(), @@ -1674,7 +1670,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// # Arguments /// /// * `tableId` - Table whose rows will be replaced. - pub fn replace_rows(&self, table_id: &str) -> TableReplaceRowCall<'a, C, NC, A> { + pub fn replace_rows(&self, table_id: &str) -> TableReplaceRowCall<'a, C, A> { TableReplaceRowCall { hub: self.hub, _table_id: table_id.to_string(), @@ -1697,7 +1693,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `tableId` - ID of the table that is being updated. - pub fn update(&self, request: &Table, table_id: &str) -> TableUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Table, table_id: &str) -> TableUpdateCall<'a, C, A> { TableUpdateCall { hub: self.hub, _request: request.clone(), @@ -1716,7 +1712,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// # Arguments /// /// * `tableId` - ID of the table to be deleted. - pub fn delete(&self, table_id: &str) -> TableDeleteCall<'a, C, NC, A> { + pub fn delete(&self, table_id: &str) -> TableDeleteCall<'a, C, A> { TableDeleteCall { hub: self.hub, _table_id: table_id.to_string(), @@ -1733,7 +1729,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &Table) -> TableInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Table) -> TableInsertCall<'a, C, A> { TableInsertCall { hub: self.hub, _request: request.clone(), @@ -1750,7 +1746,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// # Arguments /// /// * `tableId` - Identifier for the table being requested. - pub fn get(&self, table_id: &str) -> TableGetCall<'a, C, NC, A> { + pub fn get(&self, table_id: &str) -> TableGetCall<'a, C, A> { TableGetCall { hub: self.hub, _table_id: table_id.to_string(), @@ -1763,7 +1759,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Retrieves a list of tables a user owns. - pub fn list(&self) -> TableListCall<'a, C, NC, A> { + pub fn list(&self) -> TableListCall<'a, C, A> { TableListCall { hub: self.hub, _page_token: Default::default(), @@ -1781,7 +1777,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// # Arguments /// /// * `tableId` - The table into which new rows are being imported. - pub fn import_rows(&self, table_id: &str) -> TableImportRowCall<'a, C, NC, A> { + pub fn import_rows(&self, table_id: &str) -> TableImportRowCall<'a, C, A> { TableImportRowCall { hub: self.hub, _table_id: table_id.to_string(), @@ -1803,7 +1799,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// # Arguments /// /// * `name` - The name to be assigned to the new table. - pub fn import_table(&self, name: &str) -> TableImportTableCall<'a, C, NC, A> { + pub fn import_table(&self, name: &str) -> TableImportTableCall<'a, C, A> { TableImportTableCall { hub: self.hub, _name: name.to_string(), @@ -1822,7 +1818,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// # Arguments /// /// * `tableId` - ID of the table that is being copied. - pub fn copy(&self, table_id: &str) -> TableCopyCall<'a, C, NC, A> { + pub fn copy(&self, table_id: &str) -> TableCopyCall<'a, C, A> { TableCopyCall { hub: self.hub, _table_id: table_id.to_string(), @@ -1874,10 +1870,10 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct StyleListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct StyleListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _table_id: String, _page_token: Option, _max_results: Option, @@ -1886,9 +1882,9 @@ pub struct StyleListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for StyleListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for StyleListCall<'a, C, A> {} -impl<'a, C, NC, A> StyleListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> StyleListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2026,7 +2022,7 @@ impl<'a, C, NC, A> StyleListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Table whose styles are being listed - pub fn table_id(mut self, new_value: &str) -> StyleListCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> StyleListCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -2034,7 +2030,7 @@ impl<'a, C, NC, A> StyleListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Continuation token specifying which result page to return. Optional. - pub fn page_token(mut self, new_value: &str) -> StyleListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> StyleListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2042,7 +2038,7 @@ impl<'a, C, NC, A> StyleListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Maximum number of styles to return. Optional. Default is 5. - pub fn max_results(mut self, new_value: u32) -> StyleListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> StyleListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2053,7 +2049,7 @@ impl<'a, C, NC, A> StyleListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> StyleListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> StyleListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2074,7 +2070,7 @@ impl<'a, C, NC, A> StyleListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> StyleListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> StyleListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2091,7 +2087,7 @@ impl<'a, C, NC, A> StyleListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> StyleListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> StyleListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2135,10 +2131,10 @@ impl<'a, C, NC, A> StyleListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct StyleUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct StyleUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _request: StyleSetting, _table_id: String, _style_id: i32, @@ -2147,9 +2143,9 @@ pub struct StyleUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for StyleUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for StyleUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> StyleUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> StyleUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2289,7 +2285,7 @@ impl<'a, C, NC, A> StyleUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &StyleSetting) -> StyleUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &StyleSetting) -> StyleUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2299,7 +2295,7 @@ impl<'a, C, NC, A> StyleUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Table whose style is being updated. - pub fn table_id(mut self, new_value: &str) -> StyleUpdateCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> StyleUpdateCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -2309,7 +2305,7 @@ impl<'a, C, NC, A> StyleUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Identifier (within a table) for the style being updated. - pub fn style_id(mut self, new_value: i32) -> StyleUpdateCall<'a, C, NC, A> { + pub fn style_id(mut self, new_value: i32) -> StyleUpdateCall<'a, C, A> { self._style_id = new_value; self } @@ -2320,7 +2316,7 @@ impl<'a, C, NC, A> StyleUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> StyleUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> StyleUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2341,7 +2337,7 @@ impl<'a, C, NC, A> StyleUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> StyleUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> StyleUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2358,7 +2354,7 @@ impl<'a, C, NC, A> StyleUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> StyleUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> StyleUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2402,10 +2398,10 @@ impl<'a, C, NC, A> StyleUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct StyleInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct StyleInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _request: StyleSetting, _table_id: String, _delegate: Option<&'a mut Delegate>, @@ -2413,9 +2409,9 @@ pub struct StyleInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for StyleInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for StyleInsertCall<'a, C, A> {} -impl<'a, C, NC, A> StyleInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> StyleInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2554,7 +2550,7 @@ impl<'a, C, NC, A> StyleInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &StyleSetting) -> StyleInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &StyleSetting) -> StyleInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2564,7 +2560,7 @@ impl<'a, C, NC, A> StyleInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Table for which a new style is being added - pub fn table_id(mut self, new_value: &str) -> StyleInsertCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> StyleInsertCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -2575,7 +2571,7 @@ impl<'a, C, NC, A> StyleInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> StyleInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> StyleInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2596,7 +2592,7 @@ impl<'a, C, NC, A> StyleInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> StyleInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> StyleInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2613,7 +2609,7 @@ impl<'a, C, NC, A> StyleInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> StyleInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> StyleInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2651,10 +2647,10 @@ impl<'a, C, NC, A> StyleInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct StyleGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct StyleGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _table_id: String, _style_id: i32, _delegate: Option<&'a mut Delegate>, @@ -2662,9 +2658,9 @@ pub struct StyleGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for StyleGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for StyleGetCall<'a, C, A> {} -impl<'a, C, NC, A> StyleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> StyleGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2797,7 +2793,7 @@ impl<'a, C, NC, A> StyleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Table to which the requested style belongs - pub fn table_id(mut self, new_value: &str) -> StyleGetCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> StyleGetCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -2807,7 +2803,7 @@ impl<'a, C, NC, A> StyleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Identifier (integer) for a specific style in a table - pub fn style_id(mut self, new_value: i32) -> StyleGetCall<'a, C, NC, A> { + pub fn style_id(mut self, new_value: i32) -> StyleGetCall<'a, C, A> { self._style_id = new_value; self } @@ -2818,7 +2814,7 @@ impl<'a, C, NC, A> StyleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> StyleGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> StyleGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2839,7 +2835,7 @@ impl<'a, C, NC, A> StyleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> StyleGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> StyleGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2856,7 +2852,7 @@ impl<'a, C, NC, A> StyleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> StyleGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> StyleGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2894,10 +2890,10 @@ impl<'a, C, NC, A> StyleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct StyleDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct StyleDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _table_id: String, _style_id: i32, _delegate: Option<&'a mut Delegate>, @@ -2905,9 +2901,9 @@ pub struct StyleDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for StyleDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for StyleDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> StyleDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> StyleDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3029,7 +3025,7 @@ impl<'a, C, NC, A> StyleDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Table from which the style is being deleted - pub fn table_id(mut self, new_value: &str) -> StyleDeleteCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> StyleDeleteCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -3039,7 +3035,7 @@ impl<'a, C, NC, A> StyleDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Identifier (within a table) for the style being deleted - pub fn style_id(mut self, new_value: i32) -> StyleDeleteCall<'a, C, NC, A> { + pub fn style_id(mut self, new_value: i32) -> StyleDeleteCall<'a, C, A> { self._style_id = new_value; self } @@ -3050,7 +3046,7 @@ impl<'a, C, NC, A> StyleDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> StyleDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> StyleDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3071,7 +3067,7 @@ impl<'a, C, NC, A> StyleDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> StyleDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> StyleDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3088,7 +3084,7 @@ impl<'a, C, NC, A> StyleDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> StyleDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> StyleDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3132,10 +3128,10 @@ impl<'a, C, NC, A> StyleDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct StylePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct StylePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _request: StyleSetting, _table_id: String, _style_id: i32, @@ -3144,9 +3140,9 @@ pub struct StylePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for StylePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for StylePatchCall<'a, C, A> {} -impl<'a, C, NC, A> StylePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> StylePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3286,7 +3282,7 @@ impl<'a, C, NC, A> StylePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &StyleSetting) -> StylePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &StyleSetting) -> StylePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3296,7 +3292,7 @@ impl<'a, C, NC, A> StylePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Table whose style is being updated. - pub fn table_id(mut self, new_value: &str) -> StylePatchCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> StylePatchCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -3306,7 +3302,7 @@ impl<'a, C, NC, A> StylePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Identifier (within a table) for the style being updated. - pub fn style_id(mut self, new_value: i32) -> StylePatchCall<'a, C, NC, A> { + pub fn style_id(mut self, new_value: i32) -> StylePatchCall<'a, C, A> { self._style_id = new_value; self } @@ -3317,7 +3313,7 @@ impl<'a, C, NC, A> StylePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> StylePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> StylePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3338,7 +3334,7 @@ impl<'a, C, NC, A> StylePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> StylePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> StylePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3355,7 +3351,7 @@ impl<'a, C, NC, A> StylePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> StylePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> StylePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3396,10 +3392,10 @@ impl<'a, C, NC, A> StylePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct TaskListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TaskListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _table_id: String, _start_index: Option, _page_token: Option, @@ -3409,9 +3405,9 @@ pub struct TaskListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TaskListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TaskListCall<'a, C, A> {} -impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TaskListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3552,7 +3548,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Table whose tasks are being listed. - pub fn table_id(mut self, new_value: &str) -> TaskListCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> TaskListCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -3560,7 +3556,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Index of the first result returned in the current page. - pub fn start_index(mut self, new_value: u32) -> TaskListCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: u32) -> TaskListCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -3568,7 +3564,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Continuation token specifying which result page to return. - pub fn page_token(mut self, new_value: &str) -> TaskListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TaskListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -3576,7 +3572,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Maximum number of tasks to return. Default is 5. - pub fn max_results(mut self, new_value: u32) -> TaskListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> TaskListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -3587,7 +3583,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3608,7 +3604,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TaskListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TaskListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3625,7 +3621,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TaskListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TaskListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3663,10 +3659,10 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct TaskDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TaskDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _table_id: String, _task_id: String, _delegate: Option<&'a mut Delegate>, @@ -3674,9 +3670,9 @@ pub struct TaskDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TaskDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TaskDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> TaskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TaskDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3798,7 +3794,7 @@ impl<'a, C, NC, A> TaskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Table from which the task is being deleted. - pub fn table_id(mut self, new_value: &str) -> TaskDeleteCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> TaskDeleteCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -3808,7 +3804,7 @@ impl<'a, C, NC, A> TaskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The identifier of the task to delete. - pub fn task_id(mut self, new_value: &str) -> TaskDeleteCall<'a, C, NC, A> { + pub fn task_id(mut self, new_value: &str) -> TaskDeleteCall<'a, C, A> { self._task_id = new_value.to_string(); self } @@ -3819,7 +3815,7 @@ impl<'a, C, NC, A> TaskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3840,7 +3836,7 @@ impl<'a, C, NC, A> TaskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TaskDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TaskDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3857,7 +3853,7 @@ impl<'a, C, NC, A> TaskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TaskDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TaskDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3895,10 +3891,10 @@ impl<'a, C, NC, A> TaskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct TaskGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TaskGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _table_id: String, _task_id: String, _delegate: Option<&'a mut Delegate>, @@ -3906,9 +3902,9 @@ pub struct TaskGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TaskGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TaskGetCall<'a, C, A> {} -impl<'a, C, NC, A> TaskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TaskGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4041,7 +4037,7 @@ impl<'a, C, NC, A> TaskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// Table to which the task belongs. - pub fn table_id(mut self, new_value: &str) -> TaskGetCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> TaskGetCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -4051,7 +4047,7 @@ impl<'a, C, NC, A> TaskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// The identifier of the task to get. - pub fn task_id(mut self, new_value: &str) -> TaskGetCall<'a, C, NC, A> { + pub fn task_id(mut self, new_value: &str) -> TaskGetCall<'a, C, A> { self._task_id = new_value.to_string(); self } @@ -4062,7 +4058,7 @@ impl<'a, C, NC, A> TaskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4083,7 +4079,7 @@ impl<'a, C, NC, A> TaskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TaskGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TaskGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4100,7 +4096,7 @@ impl<'a, C, NC, A> TaskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TaskGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TaskGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4144,10 +4140,10 @@ impl<'a, C, NC, A> TaskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct ColumnInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ColumnInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _request: Column, _table_id: String, _delegate: Option<&'a mut Delegate>, @@ -4155,9 +4151,9 @@ pub struct ColumnInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ColumnInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ColumnInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ColumnInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ColumnInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4296,7 +4292,7 @@ impl<'a, C, NC, A> ColumnInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Column) -> ColumnInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Column) -> ColumnInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4306,7 +4302,7 @@ impl<'a, C, NC, A> ColumnInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Table for which a new column is being added. - pub fn table_id(mut self, new_value: &str) -> ColumnInsertCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> ColumnInsertCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -4317,7 +4313,7 @@ impl<'a, C, NC, A> ColumnInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ColumnInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ColumnInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4338,7 +4334,7 @@ impl<'a, C, NC, A> ColumnInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ColumnInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ColumnInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4355,7 +4351,7 @@ impl<'a, C, NC, A> ColumnInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ColumnInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ColumnInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4399,10 +4395,10 @@ impl<'a, C, NC, A> ColumnInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct ColumnUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ColumnUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _request: Column, _table_id: String, _column_id: String, @@ -4411,9 +4407,9 @@ pub struct ColumnUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ColumnUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ColumnUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ColumnUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ColumnUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4553,7 +4549,7 @@ impl<'a, C, NC, A> ColumnUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Column) -> ColumnUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Column) -> ColumnUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4563,7 +4559,7 @@ impl<'a, C, NC, A> ColumnUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Table for which the column is being updated. - pub fn table_id(mut self, new_value: &str) -> ColumnUpdateCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> ColumnUpdateCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -4573,7 +4569,7 @@ impl<'a, C, NC, A> ColumnUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Name or identifier for the column that is being updated. - pub fn column_id(mut self, new_value: &str) -> ColumnUpdateCall<'a, C, NC, A> { + pub fn column_id(mut self, new_value: &str) -> ColumnUpdateCall<'a, C, A> { self._column_id = new_value.to_string(); self } @@ -4584,7 +4580,7 @@ impl<'a, C, NC, A> ColumnUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ColumnUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ColumnUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4605,7 +4601,7 @@ impl<'a, C, NC, A> ColumnUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ColumnUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ColumnUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4622,7 +4618,7 @@ impl<'a, C, NC, A> ColumnUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ColumnUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ColumnUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4662,10 +4658,10 @@ impl<'a, C, NC, A> ColumnUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct ColumnListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ColumnListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _table_id: String, _page_token: Option, _max_results: Option, @@ -4674,9 +4670,9 @@ pub struct ColumnListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ColumnListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ColumnListCall<'a, C, A> {} -impl<'a, C, NC, A> ColumnListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ColumnListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4814,7 +4810,7 @@ impl<'a, C, NC, A> ColumnListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Table whose columns are being listed. - pub fn table_id(mut self, new_value: &str) -> ColumnListCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> ColumnListCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -4822,7 +4818,7 @@ impl<'a, C, NC, A> ColumnListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Continuation token specifying which result page to return. - pub fn page_token(mut self, new_value: &str) -> ColumnListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ColumnListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -4830,7 +4826,7 @@ impl<'a, C, NC, A> ColumnListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Maximum number of columns to return. Default is 5. - pub fn max_results(mut self, new_value: u32) -> ColumnListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> ColumnListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -4841,7 +4837,7 @@ impl<'a, C, NC, A> ColumnListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ColumnListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ColumnListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4862,7 +4858,7 @@ impl<'a, C, NC, A> ColumnListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ColumnListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ColumnListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4879,7 +4875,7 @@ impl<'a, C, NC, A> ColumnListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ColumnListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ColumnListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4923,10 +4919,10 @@ impl<'a, C, NC, A> ColumnListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct ColumnPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ColumnPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _request: Column, _table_id: String, _column_id: String, @@ -4935,9 +4931,9 @@ pub struct ColumnPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ColumnPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ColumnPatchCall<'a, C, A> {} -impl<'a, C, NC, A> ColumnPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ColumnPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5077,7 +5073,7 @@ impl<'a, C, NC, A> ColumnPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Column) -> ColumnPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Column) -> ColumnPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5087,7 +5083,7 @@ impl<'a, C, NC, A> ColumnPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Table for which the column is being updated. - pub fn table_id(mut self, new_value: &str) -> ColumnPatchCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> ColumnPatchCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -5097,7 +5093,7 @@ impl<'a, C, NC, A> ColumnPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Name or identifier for the column that is being updated. - pub fn column_id(mut self, new_value: &str) -> ColumnPatchCall<'a, C, NC, A> { + pub fn column_id(mut self, new_value: &str) -> ColumnPatchCall<'a, C, A> { self._column_id = new_value.to_string(); self } @@ -5108,7 +5104,7 @@ impl<'a, C, NC, A> ColumnPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ColumnPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ColumnPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5129,7 +5125,7 @@ impl<'a, C, NC, A> ColumnPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ColumnPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ColumnPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5146,7 +5142,7 @@ impl<'a, C, NC, A> ColumnPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ColumnPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ColumnPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5184,10 +5180,10 @@ impl<'a, C, NC, A> ColumnPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct ColumnDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ColumnDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _table_id: String, _column_id: String, _delegate: Option<&'a mut Delegate>, @@ -5195,9 +5191,9 @@ pub struct ColumnDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ColumnDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ColumnDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ColumnDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ColumnDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5319,7 +5315,7 @@ impl<'a, C, NC, A> ColumnDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Table from which the column is being deleted. - pub fn table_id(mut self, new_value: &str) -> ColumnDeleteCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> ColumnDeleteCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -5329,7 +5325,7 @@ impl<'a, C, NC, A> ColumnDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Name or identifier for the column being deleted. - pub fn column_id(mut self, new_value: &str) -> ColumnDeleteCall<'a, C, NC, A> { + pub fn column_id(mut self, new_value: &str) -> ColumnDeleteCall<'a, C, A> { self._column_id = new_value.to_string(); self } @@ -5340,7 +5336,7 @@ impl<'a, C, NC, A> ColumnDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ColumnDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ColumnDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5361,7 +5357,7 @@ impl<'a, C, NC, A> ColumnDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ColumnDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ColumnDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5378,7 +5374,7 @@ impl<'a, C, NC, A> ColumnDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ColumnDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ColumnDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5416,10 +5412,10 @@ impl<'a, C, NC, A> ColumnDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct ColumnGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ColumnGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _table_id: String, _column_id: String, _delegate: Option<&'a mut Delegate>, @@ -5427,9 +5423,9 @@ pub struct ColumnGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ColumnGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ColumnGetCall<'a, C, A> {} -impl<'a, C, NC, A> ColumnGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ColumnGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5562,7 +5558,7 @@ impl<'a, C, NC, A> ColumnGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Table to which the column belongs. - pub fn table_id(mut self, new_value: &str) -> ColumnGetCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> ColumnGetCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -5572,7 +5568,7 @@ impl<'a, C, NC, A> ColumnGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Name or identifier for the column that is being requested. - pub fn column_id(mut self, new_value: &str) -> ColumnGetCall<'a, C, NC, A> { + pub fn column_id(mut self, new_value: &str) -> ColumnGetCall<'a, C, A> { self._column_id = new_value.to_string(); self } @@ -5583,7 +5579,7 @@ impl<'a, C, NC, A> ColumnGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ColumnGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ColumnGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5604,7 +5600,7 @@ impl<'a, C, NC, A> ColumnGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ColumnGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ColumnGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5621,7 +5617,7 @@ impl<'a, C, NC, A> ColumnGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ColumnGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ColumnGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5665,10 +5661,10 @@ impl<'a, C, NC, A> ColumnGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct TemplateUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TemplateUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _request: Template, _table_id: String, _template_id: i32, @@ -5677,9 +5673,9 @@ pub struct TemplateUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TemplateUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TemplateUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> TemplateUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TemplateUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5819,7 +5815,7 @@ impl<'a, C, NC, A> TemplateUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Template) -> TemplateUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Template) -> TemplateUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5829,7 +5825,7 @@ impl<'a, C, NC, A> TemplateUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Table to which the updated template belongs - pub fn table_id(mut self, new_value: &str) -> TemplateUpdateCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> TemplateUpdateCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -5839,7 +5835,7 @@ impl<'a, C, NC, A> TemplateUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Identifier for the template that is being updated - pub fn template_id(mut self, new_value: i32) -> TemplateUpdateCall<'a, C, NC, A> { + pub fn template_id(mut self, new_value: i32) -> TemplateUpdateCall<'a, C, A> { self._template_id = new_value; self } @@ -5850,7 +5846,7 @@ impl<'a, C, NC, A> TemplateUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TemplateUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TemplateUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5871,7 +5867,7 @@ impl<'a, C, NC, A> TemplateUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TemplateUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TemplateUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5888,7 +5884,7 @@ impl<'a, C, NC, A> TemplateUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TemplateUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TemplateUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5928,10 +5924,10 @@ impl<'a, C, NC, A> TemplateUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct TemplateListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TemplateListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _table_id: String, _page_token: Option, _max_results: Option, @@ -5940,9 +5936,9 @@ pub struct TemplateListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TemplateListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TemplateListCall<'a, C, A> {} -impl<'a, C, NC, A> TemplateListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TemplateListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6080,7 +6076,7 @@ impl<'a, C, NC, A> TemplateListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Identifier for the table whose templates are being requested - pub fn table_id(mut self, new_value: &str) -> TemplateListCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> TemplateListCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -6088,7 +6084,7 @@ impl<'a, C, NC, A> TemplateListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Continuation token specifying which results page to return. Optional. - pub fn page_token(mut self, new_value: &str) -> TemplateListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TemplateListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -6096,7 +6092,7 @@ impl<'a, C, NC, A> TemplateListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Maximum number of templates to return. Optional. Default is 5. - pub fn max_results(mut self, new_value: u32) -> TemplateListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> TemplateListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -6107,7 +6103,7 @@ impl<'a, C, NC, A> TemplateListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TemplateListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TemplateListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6128,7 +6124,7 @@ impl<'a, C, NC, A> TemplateListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TemplateListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TemplateListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6145,7 +6141,7 @@ impl<'a, C, NC, A> TemplateListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TemplateListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TemplateListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6183,10 +6179,10 @@ impl<'a, C, NC, A> TemplateListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct TemplateDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TemplateDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _table_id: String, _template_id: i32, _delegate: Option<&'a mut Delegate>, @@ -6194,9 +6190,9 @@ pub struct TemplateDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TemplateDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TemplateDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> TemplateDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TemplateDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6318,7 +6314,7 @@ impl<'a, C, NC, A> TemplateDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Table from which the template is being deleted - pub fn table_id(mut self, new_value: &str) -> TemplateDeleteCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> TemplateDeleteCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -6328,7 +6324,7 @@ impl<'a, C, NC, A> TemplateDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Identifier for the template which is being deleted - pub fn template_id(mut self, new_value: i32) -> TemplateDeleteCall<'a, C, NC, A> { + pub fn template_id(mut self, new_value: i32) -> TemplateDeleteCall<'a, C, A> { self._template_id = new_value; self } @@ -6339,7 +6335,7 @@ impl<'a, C, NC, A> TemplateDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TemplateDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TemplateDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6360,7 +6356,7 @@ impl<'a, C, NC, A> TemplateDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TemplateDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TemplateDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6377,7 +6373,7 @@ impl<'a, C, NC, A> TemplateDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TemplateDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TemplateDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6421,10 +6417,10 @@ impl<'a, C, NC, A> TemplateDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct TemplateInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TemplateInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _request: Template, _table_id: String, _delegate: Option<&'a mut Delegate>, @@ -6432,9 +6428,9 @@ pub struct TemplateInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TemplateInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TemplateInsertCall<'a, C, A> {} -impl<'a, C, NC, A> TemplateInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TemplateInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6573,7 +6569,7 @@ impl<'a, C, NC, A> TemplateInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Template) -> TemplateInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Template) -> TemplateInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6583,7 +6579,7 @@ impl<'a, C, NC, A> TemplateInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Table for which a new template is being created - pub fn table_id(mut self, new_value: &str) -> TemplateInsertCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> TemplateInsertCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -6594,7 +6590,7 @@ impl<'a, C, NC, A> TemplateInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TemplateInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TemplateInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6615,7 +6611,7 @@ impl<'a, C, NC, A> TemplateInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TemplateInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TemplateInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6632,7 +6628,7 @@ impl<'a, C, NC, A> TemplateInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TemplateInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TemplateInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6676,10 +6672,10 @@ impl<'a, C, NC, A> TemplateInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct TemplatePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TemplatePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _request: Template, _table_id: String, _template_id: i32, @@ -6688,9 +6684,9 @@ pub struct TemplatePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TemplatePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TemplatePatchCall<'a, C, A> {} -impl<'a, C, NC, A> TemplatePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TemplatePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6830,7 +6826,7 @@ impl<'a, C, NC, A> TemplatePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Template) -> TemplatePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Template) -> TemplatePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6840,7 +6836,7 @@ impl<'a, C, NC, A> TemplatePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Table to which the updated template belongs - pub fn table_id(mut self, new_value: &str) -> TemplatePatchCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> TemplatePatchCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -6850,7 +6846,7 @@ impl<'a, C, NC, A> TemplatePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Identifier for the template that is being updated - pub fn template_id(mut self, new_value: i32) -> TemplatePatchCall<'a, C, NC, A> { + pub fn template_id(mut self, new_value: i32) -> TemplatePatchCall<'a, C, A> { self._template_id = new_value; self } @@ -6861,7 +6857,7 @@ impl<'a, C, NC, A> TemplatePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TemplatePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TemplatePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6882,7 +6878,7 @@ impl<'a, C, NC, A> TemplatePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TemplatePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TemplatePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6899,7 +6895,7 @@ impl<'a, C, NC, A> TemplatePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TemplatePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TemplatePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6937,10 +6933,10 @@ impl<'a, C, NC, A> TemplatePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct TemplateGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TemplateGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _table_id: String, _template_id: i32, _delegate: Option<&'a mut Delegate>, @@ -6948,9 +6944,9 @@ pub struct TemplateGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TemplateGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TemplateGetCall<'a, C, A> {} -impl<'a, C, NC, A> TemplateGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TemplateGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7083,7 +7079,7 @@ impl<'a, C, NC, A> TemplateGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Table to which the template belongs - pub fn table_id(mut self, new_value: &str) -> TemplateGetCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> TemplateGetCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -7093,7 +7089,7 @@ impl<'a, C, NC, A> TemplateGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Identifier for the template that is being requested - pub fn template_id(mut self, new_value: i32) -> TemplateGetCall<'a, C, NC, A> { + pub fn template_id(mut self, new_value: i32) -> TemplateGetCall<'a, C, A> { self._template_id = new_value; self } @@ -7104,7 +7100,7 @@ impl<'a, C, NC, A> TemplateGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TemplateGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TemplateGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7125,7 +7121,7 @@ impl<'a, C, NC, A> TemplateGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TemplateGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TemplateGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7142,7 +7138,7 @@ impl<'a, C, NC, A> TemplateGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TemplateGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TemplateGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7190,10 +7186,10 @@ impl<'a, C, NC, A> TemplateGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct QuerySqlGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct QuerySqlGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _sql: String, _typed: Option, _hdrs: Option, @@ -7202,9 +7198,9 @@ pub struct QuerySqlGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for QuerySqlGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for QuerySqlGetCall<'a, C, A> {} -impl<'a, C, NC, A> QuerySqlGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> QuerySqlGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7337,7 +7333,7 @@ impl<'a, C, NC, A> QuerySqlGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// - SELECT /// - SHOW /// - DESCRIBE - pub fn sql(mut self, new_value: &str) -> QuerySqlGetCall<'a, C, NC, A> { + pub fn sql(mut self, new_value: &str) -> QuerySqlGetCall<'a, C, A> { self._sql = new_value.to_string(); self } @@ -7345,7 +7341,7 @@ impl<'a, C, NC, A> QuerySqlGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Whether typed values are returned in the (JSON) response: numbers for numeric values and parsed geometries for KML values. Default is true. - pub fn typed(mut self, new_value: bool) -> QuerySqlGetCall<'a, C, NC, A> { + pub fn typed(mut self, new_value: bool) -> QuerySqlGetCall<'a, C, A> { self._typed = Some(new_value); self } @@ -7353,7 +7349,7 @@ impl<'a, C, NC, A> QuerySqlGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Whether column names are included (in the first row). Default is true. - pub fn hdrs(mut self, new_value: bool) -> QuerySqlGetCall<'a, C, NC, A> { + pub fn hdrs(mut self, new_value: bool) -> QuerySqlGetCall<'a, C, A> { self._hdrs = Some(new_value); self } @@ -7364,7 +7360,7 @@ impl<'a, C, NC, A> QuerySqlGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> QuerySqlGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> QuerySqlGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7385,7 +7381,7 @@ impl<'a, C, NC, A> QuerySqlGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> QuerySqlGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> QuerySqlGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7402,7 +7398,7 @@ impl<'a, C, NC, A> QuerySqlGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> QuerySqlGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> QuerySqlGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7454,10 +7450,10 @@ impl<'a, C, NC, A> QuerySqlGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct QuerySqlCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct QuerySqlCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _sql: String, _typed: Option, _hdrs: Option, @@ -7466,9 +7462,9 @@ pub struct QuerySqlCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for QuerySqlCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for QuerySqlCall<'a, C, A> {} -impl<'a, C, NC, A> QuerySqlCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> QuerySqlCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7605,7 +7601,7 @@ impl<'a, C, NC, A> QuerySqlCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// - SHOW /// - DESCRIBE /// - CREATE - pub fn sql(mut self, new_value: &str) -> QuerySqlCall<'a, C, NC, A> { + pub fn sql(mut self, new_value: &str) -> QuerySqlCall<'a, C, A> { self._sql = new_value.to_string(); self } @@ -7613,7 +7609,7 @@ impl<'a, C, NC, A> QuerySqlCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Whether typed values are returned in the (JSON) response: numbers for numeric values and parsed geometries for KML values. Default is true. - pub fn typed(mut self, new_value: bool) -> QuerySqlCall<'a, C, NC, A> { + pub fn typed(mut self, new_value: bool) -> QuerySqlCall<'a, C, A> { self._typed = Some(new_value); self } @@ -7621,7 +7617,7 @@ impl<'a, C, NC, A> QuerySqlCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Whether column names are included in the first row. Default is true. - pub fn hdrs(mut self, new_value: bool) -> QuerySqlCall<'a, C, NC, A> { + pub fn hdrs(mut self, new_value: bool) -> QuerySqlCall<'a, C, A> { self._hdrs = Some(new_value); self } @@ -7632,7 +7628,7 @@ impl<'a, C, NC, A> QuerySqlCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> QuerySqlCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> QuerySqlCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7653,7 +7649,7 @@ impl<'a, C, NC, A> QuerySqlCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> QuerySqlCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> QuerySqlCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7670,7 +7666,7 @@ impl<'a, C, NC, A> QuerySqlCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> QuerySqlCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> QuerySqlCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7715,10 +7711,10 @@ impl<'a, C, NC, A> QuerySqlCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct TablePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TablePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _request: Table, _table_id: String, _replace_view_definition: Option, @@ -7727,9 +7723,9 @@ pub struct TablePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TablePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TablePatchCall<'a, C, A> {} -impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TablePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7871,7 +7867,7 @@ impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Table) -> TablePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Table) -> TablePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7881,7 +7877,7 @@ impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// ID of the table that is being updated. - pub fn table_id(mut self, new_value: &str) -> TablePatchCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> TablePatchCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -7889,7 +7885,7 @@ impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Whether the view definition is also updated. The specified view definition replaces the existing one. Only a view can be updated with a new definition. - pub fn replace_view_definition(mut self, new_value: bool) -> TablePatchCall<'a, C, NC, A> { + pub fn replace_view_definition(mut self, new_value: bool) -> TablePatchCall<'a, C, A> { self._replace_view_definition = Some(new_value); self } @@ -7900,7 +7896,7 @@ impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TablePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TablePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7921,7 +7917,7 @@ impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TablePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TablePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7938,7 +7934,7 @@ impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TablePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TablePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7982,10 +7978,10 @@ impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .upload_resumable(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct TableReplaceRowCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableReplaceRowCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _table_id: String, _start_line: Option, _is_strict: Option, @@ -7997,9 +7993,9 @@ pub struct TableReplaceRowCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableReplaceRowCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableReplaceRowCall<'a, C, A> {} -impl<'a, C, NC, A> TableReplaceRowCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableReplaceRowCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8255,7 +8251,7 @@ impl<'a, C, NC, A> TableReplaceRowCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Table whose rows will be replaced. - pub fn table_id(mut self, new_value: &str) -> TableReplaceRowCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> TableReplaceRowCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -8263,7 +8259,7 @@ impl<'a, C, NC, A> TableReplaceRowCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The index of the first line from which to start importing, inclusive. Default is 0. - pub fn start_line(mut self, new_value: i32) -> TableReplaceRowCall<'a, C, NC, A> { + pub fn start_line(mut self, new_value: i32) -> TableReplaceRowCall<'a, C, A> { self._start_line = Some(new_value); self } @@ -8271,7 +8267,7 @@ impl<'a, C, NC, A> TableReplaceRowCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Whether the imported CSV must have the same number of column values for each row. If true, throws an exception if the CSV does not have the same number of columns. If false, rows with fewer column values will be padded with empty values. Default is true. - pub fn is_strict(mut self, new_value: bool) -> TableReplaceRowCall<'a, C, NC, A> { + pub fn is_strict(mut self, new_value: bool) -> TableReplaceRowCall<'a, C, A> { self._is_strict = Some(new_value); self } @@ -8279,7 +8275,7 @@ impl<'a, C, NC, A> TableReplaceRowCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The index of the line up to which data will be imported. Default is to import the entire file. If endLine is negative, it is an offset from the end of the file; the imported content will exclude the last endLine lines. - pub fn end_line(mut self, new_value: i32) -> TableReplaceRowCall<'a, C, NC, A> { + pub fn end_line(mut self, new_value: i32) -> TableReplaceRowCall<'a, C, A> { self._end_line = Some(new_value); self } @@ -8287,7 +8283,7 @@ impl<'a, C, NC, A> TableReplaceRowCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The encoding of the content. Default is UTF-8. Use 'auto-detect' if you are unsure of the encoding. - pub fn encoding(mut self, new_value: &str) -> TableReplaceRowCall<'a, C, NC, A> { + pub fn encoding(mut self, new_value: &str) -> TableReplaceRowCall<'a, C, A> { self._encoding = Some(new_value.to_string()); self } @@ -8295,7 +8291,7 @@ impl<'a, C, NC, A> TableReplaceRowCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The delimiter used to separate cell values. This can only consist of a single character. Default is ,. - pub fn delimiter(mut self, new_value: &str) -> TableReplaceRowCall<'a, C, NC, A> { + pub fn delimiter(mut self, new_value: &str) -> TableReplaceRowCall<'a, C, A> { self._delimiter = Some(new_value.to_string()); self } @@ -8306,7 +8302,7 @@ impl<'a, C, NC, A> TableReplaceRowCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableReplaceRowCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableReplaceRowCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8327,7 +8323,7 @@ impl<'a, C, NC, A> TableReplaceRowCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableReplaceRowCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableReplaceRowCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8344,7 +8340,7 @@ impl<'a, C, NC, A> TableReplaceRowCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableReplaceRowCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableReplaceRowCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8389,10 +8385,10 @@ impl<'a, C, NC, A> TableReplaceRowCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct TableUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _request: Table, _table_id: String, _replace_view_definition: Option, @@ -8401,9 +8397,9 @@ pub struct TableUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> TableUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8545,7 +8541,7 @@ impl<'a, C, NC, A> TableUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Table) -> TableUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Table) -> TableUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8555,7 +8551,7 @@ impl<'a, C, NC, A> TableUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// ID of the table that is being updated. - pub fn table_id(mut self, new_value: &str) -> TableUpdateCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> TableUpdateCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -8563,7 +8559,7 @@ impl<'a, C, NC, A> TableUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Whether the view definition is also updated. The specified view definition replaces the existing one. Only a view can be updated with a new definition. - pub fn replace_view_definition(mut self, new_value: bool) -> TableUpdateCall<'a, C, NC, A> { + pub fn replace_view_definition(mut self, new_value: bool) -> TableUpdateCall<'a, C, A> { self._replace_view_definition = Some(new_value); self } @@ -8574,7 +8570,7 @@ impl<'a, C, NC, A> TableUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8595,7 +8591,7 @@ impl<'a, C, NC, A> TableUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8612,7 +8608,7 @@ impl<'a, C, NC, A> TableUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8650,19 +8646,19 @@ impl<'a, C, NC, A> TableUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct TableDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _table_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> TableDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8783,7 +8779,7 @@ impl<'a, C, NC, A> TableDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// ID of the table to be deleted. - pub fn table_id(mut self, new_value: &str) -> TableDeleteCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> TableDeleteCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -8794,7 +8790,7 @@ impl<'a, C, NC, A> TableDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8815,7 +8811,7 @@ impl<'a, C, NC, A> TableDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8832,7 +8828,7 @@ impl<'a, C, NC, A> TableDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8876,19 +8872,19 @@ impl<'a, C, NC, A> TableDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct TableInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _request: Table, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableInsertCall<'a, C, A> {} -impl<'a, C, NC, A> TableInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9002,7 +8998,7 @@ impl<'a, C, NC, A> TableInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Table) -> TableInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Table) -> TableInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9013,7 +9009,7 @@ impl<'a, C, NC, A> TableInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9034,7 +9030,7 @@ impl<'a, C, NC, A> TableInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9051,7 +9047,7 @@ impl<'a, C, NC, A> TableInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9089,19 +9085,19 @@ impl<'a, C, NC, A> TableInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct TableGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _table_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableGetCall<'a, C, A> {} -impl<'a, C, NC, A> TableGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9233,7 +9229,7 @@ impl<'a, C, NC, A> TableGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Identifier for the table being requested. - pub fn table_id(mut self, new_value: &str) -> TableGetCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> TableGetCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -9244,7 +9240,7 @@ impl<'a, C, NC, A> TableGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9265,7 +9261,7 @@ impl<'a, C, NC, A> TableGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9282,7 +9278,7 @@ impl<'a, C, NC, A> TableGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9322,10 +9318,10 @@ impl<'a, C, NC, A> TableGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct TableListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _page_token: Option, _max_results: Option, _delegate: Option<&'a mut Delegate>, @@ -9333,9 +9329,9 @@ pub struct TableListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableListCall<'a, C, A> {} -impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9446,7 +9442,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Continuation token specifying which result page to return. - pub fn page_token(mut self, new_value: &str) -> TableListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TableListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -9454,7 +9450,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Maximum number of tables to return. Default is 5. - pub fn max_results(mut self, new_value: u32) -> TableListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> TableListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -9465,7 +9461,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9486,7 +9482,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9503,7 +9499,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9547,10 +9543,10 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .upload_resumable(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct TableImportRowCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableImportRowCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _table_id: String, _start_line: Option, _is_strict: Option, @@ -9562,9 +9558,9 @@ pub struct TableImportRowCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableImportRowCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableImportRowCall<'a, C, A> {} -impl<'a, C, NC, A> TableImportRowCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableImportRowCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9820,7 +9816,7 @@ impl<'a, C, NC, A> TableImportRowCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The table into which new rows are being imported. - pub fn table_id(mut self, new_value: &str) -> TableImportRowCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> TableImportRowCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -9828,7 +9824,7 @@ impl<'a, C, NC, A> TableImportRowCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The index of the first line from which to start importing, inclusive. Default is 0. - pub fn start_line(mut self, new_value: i32) -> TableImportRowCall<'a, C, NC, A> { + pub fn start_line(mut self, new_value: i32) -> TableImportRowCall<'a, C, A> { self._start_line = Some(new_value); self } @@ -9836,7 +9832,7 @@ impl<'a, C, NC, A> TableImportRowCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Whether the imported CSV must have the same number of values for each row. If false, rows with fewer values will be padded with empty values. Default is true. - pub fn is_strict(mut self, new_value: bool) -> TableImportRowCall<'a, C, NC, A> { + pub fn is_strict(mut self, new_value: bool) -> TableImportRowCall<'a, C, A> { self._is_strict = Some(new_value); self } @@ -9844,7 +9840,7 @@ impl<'a, C, NC, A> TableImportRowCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The index of the line up to which data will be imported. Default is to import the entire file. If endLine is negative, it is an offset from the end of the file; the imported content will exclude the last endLine lines. - pub fn end_line(mut self, new_value: i32) -> TableImportRowCall<'a, C, NC, A> { + pub fn end_line(mut self, new_value: i32) -> TableImportRowCall<'a, C, A> { self._end_line = Some(new_value); self } @@ -9852,7 +9848,7 @@ impl<'a, C, NC, A> TableImportRowCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The encoding of the content. Default is UTF-8. Use auto-detect if you are unsure of the encoding. - pub fn encoding(mut self, new_value: &str) -> TableImportRowCall<'a, C, NC, A> { + pub fn encoding(mut self, new_value: &str) -> TableImportRowCall<'a, C, A> { self._encoding = Some(new_value.to_string()); self } @@ -9860,7 +9856,7 @@ impl<'a, C, NC, A> TableImportRowCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The delimiter used to separate cell values. This can only consist of a single character. Default is ,. - pub fn delimiter(mut self, new_value: &str) -> TableImportRowCall<'a, C, NC, A> { + pub fn delimiter(mut self, new_value: &str) -> TableImportRowCall<'a, C, A> { self._delimiter = Some(new_value.to_string()); self } @@ -9871,7 +9867,7 @@ impl<'a, C, NC, A> TableImportRowCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableImportRowCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableImportRowCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9892,7 +9888,7 @@ impl<'a, C, NC, A> TableImportRowCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableImportRowCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableImportRowCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9909,7 +9905,7 @@ impl<'a, C, NC, A> TableImportRowCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableImportRowCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableImportRowCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9950,10 +9946,10 @@ impl<'a, C, NC, A> TableImportRowCall<'a, C, NC, A> where NC: hyper::net::Networ /// .upload_resumable(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct TableImportTableCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableImportTableCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _name: String, _encoding: Option, _delimiter: Option, @@ -9962,9 +9958,9 @@ pub struct TableImportTableCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableImportTableCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableImportTableCall<'a, C, A> {} -impl<'a, C, NC, A> TableImportTableCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableImportTableCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10187,7 +10183,7 @@ impl<'a, C, NC, A> TableImportTableCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The name to be assigned to the new table. - pub fn name(mut self, new_value: &str) -> TableImportTableCall<'a, C, NC, A> { + pub fn name(mut self, new_value: &str) -> TableImportTableCall<'a, C, A> { self._name = new_value.to_string(); self } @@ -10195,7 +10191,7 @@ impl<'a, C, NC, A> TableImportTableCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The encoding of the content. Default is UTF-8. Use auto-detect if you are unsure of the encoding. - pub fn encoding(mut self, new_value: &str) -> TableImportTableCall<'a, C, NC, A> { + pub fn encoding(mut self, new_value: &str) -> TableImportTableCall<'a, C, A> { self._encoding = Some(new_value.to_string()); self } @@ -10203,7 +10199,7 @@ impl<'a, C, NC, A> TableImportTableCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The delimiter used to separate cell values. This can only consist of a single character. Default is ,. - pub fn delimiter(mut self, new_value: &str) -> TableImportTableCall<'a, C, NC, A> { + pub fn delimiter(mut self, new_value: &str) -> TableImportTableCall<'a, C, A> { self._delimiter = Some(new_value.to_string()); self } @@ -10214,7 +10210,7 @@ impl<'a, C, NC, A> TableImportTableCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableImportTableCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableImportTableCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10235,7 +10231,7 @@ impl<'a, C, NC, A> TableImportTableCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableImportTableCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableImportTableCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10252,7 +10248,7 @@ impl<'a, C, NC, A> TableImportTableCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableImportTableCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableImportTableCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10291,10 +10287,10 @@ impl<'a, C, NC, A> TableImportTableCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct TableCopyCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableCopyCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Fusiontables, + hub: &'a Fusiontables, _table_id: String, _copy_presentation: Option, _delegate: Option<&'a mut Delegate>, @@ -10302,9 +10298,9 @@ pub struct TableCopyCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableCopyCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableCopyCall<'a, C, A> {} -impl<'a, C, NC, A> TableCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableCopyCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10439,7 +10435,7 @@ impl<'a, C, NC, A> TableCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// ID of the table that is being copied. - pub fn table_id(mut self, new_value: &str) -> TableCopyCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> TableCopyCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -10447,7 +10443,7 @@ impl<'a, C, NC, A> TableCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether to also copy tabs, styles, and templates. Default is false. - pub fn copy_presentation(mut self, new_value: bool) -> TableCopyCall<'a, C, NC, A> { + pub fn copy_presentation(mut self, new_value: bool) -> TableCopyCall<'a, C, A> { self._copy_presentation = Some(new_value); self } @@ -10458,7 +10454,7 @@ impl<'a, C, NC, A> TableCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableCopyCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableCopyCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10479,7 +10475,7 @@ impl<'a, C, NC, A> TableCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableCopyCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableCopyCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10496,7 +10492,7 @@ impl<'a, C, NC, A> TableCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableCopyCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableCopyCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/games1/Cargo.toml b/gen/games1/Cargo.toml index 9824c7da2e4..e0a53bfede8 100644 --- a/gen/games1/Cargo.toml +++ b/gen/games1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-games1" -version = "0.1.4+20150325" +version = "0.1.5+20150325" authors = ["Sebastian Thiel "] description = "A complete library to interact with Games (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/games1" homepage = "https://developers.google.com/games/services/" -documentation = "http://byron.github.io/google-apis-rs/google-games1" +documentation = "http://byron.github.io/google-apis-rs/google_games1" license = "MIT" keywords = ["games", "google", "protocol", "web", "api"] diff --git a/gen/games1/README.md b/gen/games1/README.md index c52fb245753..49a55982927 100644 --- a/gen/games1/README.md +++ b/gen/games1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-games1` library allows access to all features of the *Google Games* service. -This documentation was generated from *Games* crate version *0.1.4+20150325*, where *20150325* is the exact revision of the *games:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *Games* crate version *0.1.5+20150325*, where *20150325* is the exact revision of the *games:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *Games* *v1* API can be found at the [official documentation site](https://developers.google.com/games/services/). diff --git a/gen/games1/src/cmn.rs b/gen/games1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/games1/src/cmn.rs +++ b/gen/games1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/games1/src/lib.rs b/gen/games1/src/lib.rs index ec8a2672dfa..83a3ab6629e 100644 --- a/gen/games1/src/lib.rs +++ b/gen/games1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *Games* crate version *0.1.4+20150325*, where *20150325* is the exact revision of the *games:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *Games* crate version *0.1.5+20150325*, where *20150325* is the exact revision of the *games:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *Games* *v1* API can be found at the //! [official documentation site](https://developers.google.com/games/services/). @@ -225,7 +225,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -326,76 +325,73 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Games { +pub struct Games { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Games {} +impl<'a, C, A> Hub for Games {} -impl<'a, C, NC, A> Games - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Games + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Games { + pub fn new(client: C, authenticator: A) -> Games { Games { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn achievement_definitions(&'a self) -> AchievementDefinitionMethods<'a, C, NC, A> { + pub fn achievement_definitions(&'a self) -> AchievementDefinitionMethods<'a, C, A> { AchievementDefinitionMethods { hub: &self } } - pub fn achievements(&'a self) -> AchievementMethods<'a, C, NC, A> { + pub fn achievements(&'a self) -> AchievementMethods<'a, C, A> { AchievementMethods { hub: &self } } - pub fn applications(&'a self) -> ApplicationMethods<'a, C, NC, A> { + pub fn applications(&'a self) -> ApplicationMethods<'a, C, A> { ApplicationMethods { hub: &self } } - pub fn events(&'a self) -> EventMethods<'a, C, NC, A> { + pub fn events(&'a self) -> EventMethods<'a, C, A> { EventMethods { hub: &self } } - pub fn leaderboards(&'a self) -> LeaderboardMethods<'a, C, NC, A> { + pub fn leaderboards(&'a self) -> LeaderboardMethods<'a, C, A> { LeaderboardMethods { hub: &self } } - pub fn metagame(&'a self) -> MetagameMethods<'a, C, NC, A> { + pub fn metagame(&'a self) -> MetagameMethods<'a, C, A> { MetagameMethods { hub: &self } } - pub fn players(&'a self) -> PlayerMethods<'a, C, NC, A> { + pub fn players(&'a self) -> PlayerMethods<'a, C, A> { PlayerMethods { hub: &self } } - pub fn pushtokens(&'a self) -> PushtokenMethods<'a, C, NC, A> { + pub fn pushtokens(&'a self) -> PushtokenMethods<'a, C, A> { PushtokenMethods { hub: &self } } - pub fn quest_milestones(&'a self) -> QuestMilestoneMethods<'a, C, NC, A> { + pub fn quest_milestones(&'a self) -> QuestMilestoneMethods<'a, C, A> { QuestMilestoneMethods { hub: &self } } - pub fn quests(&'a self) -> QuestMethods<'a, C, NC, A> { + pub fn quests(&'a self) -> QuestMethods<'a, C, A> { QuestMethods { hub: &self } } - pub fn revisions(&'a self) -> RevisionMethods<'a, C, NC, A> { + pub fn revisions(&'a self) -> RevisionMethods<'a, C, A> { RevisionMethods { hub: &self } } - pub fn rooms(&'a self) -> RoomMethods<'a, C, NC, A> { + pub fn rooms(&'a self) -> RoomMethods<'a, C, A> { RoomMethods { hub: &self } } - pub fn scores(&'a self) -> ScoreMethods<'a, C, NC, A> { + pub fn scores(&'a self) -> ScoreMethods<'a, C, A> { ScoreMethods { hub: &self } } - pub fn snapshots(&'a self) -> SnapshotMethods<'a, C, NC, A> { + pub fn snapshots(&'a self) -> SnapshotMethods<'a, C, A> { SnapshotMethods { hub: &self } } - pub fn turn_based_matches(&'a self) -> TurnBasedMatcheMethods<'a, C, NC, A> { + pub fn turn_based_matches(&'a self) -> TurnBasedMatcheMethods<'a, C, A> { TurnBasedMatcheMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -3135,15 +3131,15 @@ impl Part for GamesAchievementSetStepsAtLeast {} /// let rb = hub.achievements(); /// # } /// ``` -pub struct AchievementMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AchievementMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, } -impl<'a, C, NC, A> MethodsBuilder for AchievementMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AchievementMethods<'a, C, A> {} -impl<'a, C, NC, A> AchievementMethods<'a, C, NC, A> { +impl<'a, C, A> AchievementMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3152,7 +3148,7 @@ impl<'a, C, NC, A> AchievementMethods<'a, C, NC, A> { /// # Arguments /// /// * `playerId` - A player ID. A value of me may be used in place of the authenticated player's ID. - pub fn list(&self, player_id: &str) -> AchievementListCall<'a, C, NC, A> { + pub fn list(&self, player_id: &str) -> AchievementListCall<'a, C, A> { AchievementListCall { hub: self.hub, _player_id: player_id.to_string(), @@ -3174,7 +3170,7 @@ impl<'a, C, NC, A> AchievementMethods<'a, C, NC, A> { /// /// * `achievementId` - The ID of the achievement used by this method. /// * `stepsToIncrement` - The number of steps to increment. - pub fn increment(&self, achievement_id: &str, steps_to_increment: i32) -> AchievementIncrementCall<'a, C, NC, A> { + pub fn increment(&self, achievement_id: &str, steps_to_increment: i32) -> AchievementIncrementCall<'a, C, A> { AchievementIncrementCall { hub: self.hub, _achievement_id: achievement_id.to_string(), @@ -3194,7 +3190,7 @@ impl<'a, C, NC, A> AchievementMethods<'a, C, NC, A> { /// /// * `achievementId` - The ID of the achievement used by this method. /// * `steps` - The minimum value to set the steps to. - pub fn set_steps_at_least(&self, achievement_id: &str, steps: i32) -> AchievementSetStepsAtLeastCall<'a, C, NC, A> { + pub fn set_steps_at_least(&self, achievement_id: &str, steps: i32) -> AchievementSetStepsAtLeastCall<'a, C, A> { AchievementSetStepsAtLeastCall { hub: self.hub, _achievement_id: achievement_id.to_string(), @@ -3212,7 +3208,7 @@ impl<'a, C, NC, A> AchievementMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn update_multiple(&self, request: &AchievementUpdateMultipleRequest) -> AchievementUpdateMultipleCall<'a, C, NC, A> { + pub fn update_multiple(&self, request: &AchievementUpdateMultipleRequest) -> AchievementUpdateMultipleCall<'a, C, A> { AchievementUpdateMultipleCall { hub: self.hub, _request: request.clone(), @@ -3229,7 +3225,7 @@ impl<'a, C, NC, A> AchievementMethods<'a, C, NC, A> { /// # Arguments /// /// * `achievementId` - The ID of the achievement used by this method. - pub fn reveal(&self, achievement_id: &str) -> AchievementRevealCall<'a, C, NC, A> { + pub fn reveal(&self, achievement_id: &str) -> AchievementRevealCall<'a, C, A> { AchievementRevealCall { hub: self.hub, _achievement_id: achievement_id.to_string(), @@ -3246,7 +3242,7 @@ impl<'a, C, NC, A> AchievementMethods<'a, C, NC, A> { /// # Arguments /// /// * `achievementId` - The ID of the achievement used by this method. - pub fn unlock(&self, achievement_id: &str) -> AchievementUnlockCall<'a, C, NC, A> { + pub fn unlock(&self, achievement_id: &str) -> AchievementUnlockCall<'a, C, A> { AchievementUnlockCall { hub: self.hub, _achievement_id: achievement_id.to_string(), @@ -3287,15 +3283,15 @@ impl<'a, C, NC, A> AchievementMethods<'a, C, NC, A> { /// let rb = hub.leaderboards(); /// # } /// ``` -pub struct LeaderboardMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LeaderboardMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, } -impl<'a, C, NC, A> MethodsBuilder for LeaderboardMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for LeaderboardMethods<'a, C, A> {} -impl<'a, C, NC, A> LeaderboardMethods<'a, C, NC, A> { +impl<'a, C, A> LeaderboardMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3304,7 +3300,7 @@ impl<'a, C, NC, A> LeaderboardMethods<'a, C, NC, A> { /// # Arguments /// /// * `leaderboardId` - The ID of the leaderboard. - pub fn get(&self, leaderboard_id: &str) -> LeaderboardGetCall<'a, C, NC, A> { + pub fn get(&self, leaderboard_id: &str) -> LeaderboardGetCall<'a, C, A> { LeaderboardGetCall { hub: self.hub, _leaderboard_id: leaderboard_id.to_string(), @@ -3318,7 +3314,7 @@ impl<'a, C, NC, A> LeaderboardMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Lists all the leaderboard metadata for your application. - pub fn list(&self) -> LeaderboardListCall<'a, C, NC, A> { + pub fn list(&self) -> LeaderboardListCall<'a, C, A> { LeaderboardListCall { hub: self.hub, _page_token: Default::default(), @@ -3361,15 +3357,15 @@ impl<'a, C, NC, A> LeaderboardMethods<'a, C, NC, A> { /// let rb = hub.metagame(); /// # } /// ``` -pub struct MetagameMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MetagameMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, } -impl<'a, C, NC, A> MethodsBuilder for MetagameMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for MetagameMethods<'a, C, A> {} -impl<'a, C, NC, A> MetagameMethods<'a, C, NC, A> { +impl<'a, C, A> MetagameMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3379,7 +3375,7 @@ impl<'a, C, NC, A> MetagameMethods<'a, C, NC, A> { /// /// * `playerId` - A player ID. A value of me may be used in place of the authenticated player's ID. /// * `collection` - The collection of categories for which data will be returned. - pub fn list_categories_by_player(&self, player_id: &str, collection: &str) -> MetagameListCategoriesByPlayerCall<'a, C, NC, A> { + pub fn list_categories_by_player(&self, player_id: &str, collection: &str) -> MetagameListCategoriesByPlayerCall<'a, C, A> { MetagameListCategoriesByPlayerCall { hub: self.hub, _player_id: player_id.to_string(), @@ -3396,7 +3392,7 @@ impl<'a, C, NC, A> MetagameMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Return the metagame configuration data for the calling application. - pub fn get_metagame_config(&self) -> MetagameGetMetagameConfigCall<'a, C, NC, A> { + pub fn get_metagame_config(&self) -> MetagameGetMetagameConfigCall<'a, C, A> { MetagameGetMetagameConfigCall { hub: self.hub, _delegate: Default::default(), @@ -3436,15 +3432,15 @@ impl<'a, C, NC, A> MetagameMethods<'a, C, NC, A> { /// let rb = hub.players(); /// # } /// ``` -pub struct PlayerMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlayerMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, } -impl<'a, C, NC, A> MethodsBuilder for PlayerMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PlayerMethods<'a, C, A> {} -impl<'a, C, NC, A> PlayerMethods<'a, C, NC, A> { +impl<'a, C, A> PlayerMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3453,7 +3449,7 @@ impl<'a, C, NC, A> PlayerMethods<'a, C, NC, A> { /// # Arguments /// /// * `collection` - Collection of players being retrieved - pub fn list(&self, collection: &str) -> PlayerListCall<'a, C, NC, A> { + pub fn list(&self, collection: &str) -> PlayerListCall<'a, C, A> { PlayerListCall { hub: self.hub, _collection: collection.to_string(), @@ -3473,7 +3469,7 @@ impl<'a, C, NC, A> PlayerMethods<'a, C, NC, A> { /// # Arguments /// /// * `playerId` - A player ID. A value of me may be used in place of the authenticated player's ID. - pub fn get(&self, player_id: &str) -> PlayerGetCall<'a, C, NC, A> { + pub fn get(&self, player_id: &str) -> PlayerGetCall<'a, C, A> { PlayerGetCall { hub: self.hub, _player_id: player_id.to_string(), @@ -3515,15 +3511,15 @@ impl<'a, C, NC, A> PlayerMethods<'a, C, NC, A> { /// let rb = hub.quests(); /// # } /// ``` -pub struct QuestMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct QuestMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, } -impl<'a, C, NC, A> MethodsBuilder for QuestMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for QuestMethods<'a, C, A> {} -impl<'a, C, NC, A> QuestMethods<'a, C, NC, A> { +impl<'a, C, A> QuestMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3532,7 +3528,7 @@ impl<'a, C, NC, A> QuestMethods<'a, C, NC, A> { /// # Arguments /// /// * `questId` - The ID of the quest. - pub fn accept(&self, quest_id: &str) -> QuestAcceptCall<'a, C, NC, A> { + pub fn accept(&self, quest_id: &str) -> QuestAcceptCall<'a, C, A> { QuestAcceptCall { hub: self.hub, _quest_id: quest_id.to_string(), @@ -3550,7 +3546,7 @@ impl<'a, C, NC, A> QuestMethods<'a, C, NC, A> { /// # Arguments /// /// * `playerId` - A player ID. A value of me may be used in place of the authenticated player's ID. - pub fn list(&self, player_id: &str) -> QuestListCall<'a, C, NC, A> { + pub fn list(&self, player_id: &str) -> QuestListCall<'a, C, A> { QuestListCall { hub: self.hub, _player_id: player_id.to_string(), @@ -3594,15 +3590,15 @@ impl<'a, C, NC, A> QuestMethods<'a, C, NC, A> { /// let rb = hub.snapshots(); /// # } /// ``` -pub struct SnapshotMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SnapshotMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, } -impl<'a, C, NC, A> MethodsBuilder for SnapshotMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for SnapshotMethods<'a, C, A> {} -impl<'a, C, NC, A> SnapshotMethods<'a, C, NC, A> { +impl<'a, C, A> SnapshotMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3611,7 +3607,7 @@ impl<'a, C, NC, A> SnapshotMethods<'a, C, NC, A> { /// # Arguments /// /// * `snapshotId` - The ID of the snapshot. - pub fn get(&self, snapshot_id: &str) -> SnapshotGetCall<'a, C, NC, A> { + pub fn get(&self, snapshot_id: &str) -> SnapshotGetCall<'a, C, A> { SnapshotGetCall { hub: self.hub, _snapshot_id: snapshot_id.to_string(), @@ -3629,7 +3625,7 @@ impl<'a, C, NC, A> SnapshotMethods<'a, C, NC, A> { /// # Arguments /// /// * `playerId` - A player ID. A value of me may be used in place of the authenticated player's ID. - pub fn list(&self, player_id: &str) -> SnapshotListCall<'a, C, NC, A> { + pub fn list(&self, player_id: &str) -> SnapshotListCall<'a, C, A> { SnapshotListCall { hub: self.hub, _player_id: player_id.to_string(), @@ -3673,15 +3669,15 @@ impl<'a, C, NC, A> SnapshotMethods<'a, C, NC, A> { /// let rb = hub.turn_based_matches(); /// # } /// ``` -pub struct TurnBasedMatcheMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TurnBasedMatcheMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, } -impl<'a, C, NC, A> MethodsBuilder for TurnBasedMatcheMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TurnBasedMatcheMethods<'a, C, A> {} -impl<'a, C, NC, A> TurnBasedMatcheMethods<'a, C, NC, A> { +impl<'a, C, A> TurnBasedMatcheMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3690,7 +3686,7 @@ impl<'a, C, NC, A> TurnBasedMatcheMethods<'a, C, NC, A> { /// # Arguments /// /// * `matchId` - The ID of the match. - pub fn dismiss(&self, match_id: &str) -> TurnBasedMatcheDismisCall<'a, C, NC, A> { + pub fn dismiss(&self, match_id: &str) -> TurnBasedMatcheDismisCall<'a, C, A> { TurnBasedMatcheDismisCall { hub: self.hub, _match_id: match_id.to_string(), @@ -3703,7 +3699,7 @@ impl<'a, C, NC, A> TurnBasedMatcheMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Returns turn-based matches the player is or was involved in that changed since the last sync call, with the least recent changes coming first. Matches that should be removed from the local cache will have a status of MATCH_DELETED. - pub fn sync(&self) -> TurnBasedMatcheSyncCall<'a, C, NC, A> { + pub fn sync(&self) -> TurnBasedMatcheSyncCall<'a, C, A> { TurnBasedMatcheSyncCall { hub: self.hub, _page_token: Default::default(), @@ -3724,7 +3720,7 @@ impl<'a, C, NC, A> TurnBasedMatcheMethods<'a, C, NC, A> { /// # Arguments /// /// * `matchId` - The ID of the match. - pub fn decline(&self, match_id: &str) -> TurnBasedMatcheDeclineCall<'a, C, NC, A> { + pub fn decline(&self, match_id: &str) -> TurnBasedMatcheDeclineCall<'a, C, A> { TurnBasedMatcheDeclineCall { hub: self.hub, _match_id: match_id.to_string(), @@ -3742,7 +3738,7 @@ impl<'a, C, NC, A> TurnBasedMatcheMethods<'a, C, NC, A> { /// # Arguments /// /// * `matchId` - The ID of the match. - pub fn get(&self, match_id: &str) -> TurnBasedMatcheGetCall<'a, C, NC, A> { + pub fn get(&self, match_id: &str) -> TurnBasedMatcheGetCall<'a, C, A> { TurnBasedMatcheGetCall { hub: self.hub, _match_id: match_id.to_string(), @@ -3761,7 +3757,7 @@ impl<'a, C, NC, A> TurnBasedMatcheMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn create(&self, request: &TurnBasedMatchCreateRequest) -> TurnBasedMatcheCreateCall<'a, C, NC, A> { + pub fn create(&self, request: &TurnBasedMatchCreateRequest) -> TurnBasedMatcheCreateCall<'a, C, A> { TurnBasedMatcheCreateCall { hub: self.hub, _request: request.clone(), @@ -3779,7 +3775,7 @@ impl<'a, C, NC, A> TurnBasedMatcheMethods<'a, C, NC, A> { /// # Arguments /// /// * `matchId` - The ID of the match. - pub fn join(&self, match_id: &str) -> TurnBasedMatcheJoinCall<'a, C, NC, A> { + pub fn join(&self, match_id: &str) -> TurnBasedMatcheJoinCall<'a, C, A> { TurnBasedMatcheJoinCall { hub: self.hub, _match_id: match_id.to_string(), @@ -3798,7 +3794,7 @@ impl<'a, C, NC, A> TurnBasedMatcheMethods<'a, C, NC, A> { /// /// * `matchId` - The ID of the match. /// * `matchVersion` - The version of the match being updated. - pub fn leave_turn(&self, match_id: &str, match_version: i32) -> TurnBasedMatcheLeaveTurnCall<'a, C, NC, A> { + pub fn leave_turn(&self, match_id: &str, match_version: i32) -> TurnBasedMatcheLeaveTurnCall<'a, C, A> { TurnBasedMatcheLeaveTurnCall { hub: self.hub, _match_id: match_id.to_string(), @@ -3818,7 +3814,7 @@ impl<'a, C, NC, A> TurnBasedMatcheMethods<'a, C, NC, A> { /// # Arguments /// /// * `matchId` - The ID of the match. - pub fn cancel(&self, match_id: &str) -> TurnBasedMatcheCancelCall<'a, C, NC, A> { + pub fn cancel(&self, match_id: &str) -> TurnBasedMatcheCancelCall<'a, C, A> { TurnBasedMatcheCancelCall { hub: self.hub, _match_id: match_id.to_string(), @@ -3836,7 +3832,7 @@ impl<'a, C, NC, A> TurnBasedMatcheMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `matchId` - The ID of the match. - pub fn finish(&self, request: &TurnBasedMatchResults, match_id: &str) -> TurnBasedMatcheFinishCall<'a, C, NC, A> { + pub fn finish(&self, request: &TurnBasedMatchResults, match_id: &str) -> TurnBasedMatcheFinishCall<'a, C, A> { TurnBasedMatcheFinishCall { hub: self.hub, _request: request.clone(), @@ -3855,7 +3851,7 @@ impl<'a, C, NC, A> TurnBasedMatcheMethods<'a, C, NC, A> { /// # Arguments /// /// * `matchId` - The ID of the match. - pub fn leave(&self, match_id: &str) -> TurnBasedMatcheLeaveCall<'a, C, NC, A> { + pub fn leave(&self, match_id: &str) -> TurnBasedMatcheLeaveCall<'a, C, A> { TurnBasedMatcheLeaveCall { hub: self.hub, _match_id: match_id.to_string(), @@ -3869,7 +3865,7 @@ impl<'a, C, NC, A> TurnBasedMatcheMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Returns turn-based matches the player is or was involved in. - pub fn list(&self) -> TurnBasedMatcheListCall<'a, C, NC, A> { + pub fn list(&self) -> TurnBasedMatcheListCall<'a, C, A> { TurnBasedMatcheListCall { hub: self.hub, _page_token: Default::default(), @@ -3891,7 +3887,7 @@ impl<'a, C, NC, A> TurnBasedMatcheMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `matchId` - The ID of the match. - pub fn take_turn(&self, request: &TurnBasedMatchTurn, match_id: &str) -> TurnBasedMatcheTakeTurnCall<'a, C, NC, A> { + pub fn take_turn(&self, request: &TurnBasedMatchTurn, match_id: &str) -> TurnBasedMatcheTakeTurnCall<'a, C, A> { TurnBasedMatcheTakeTurnCall { hub: self.hub, _request: request.clone(), @@ -3910,7 +3906,7 @@ impl<'a, C, NC, A> TurnBasedMatcheMethods<'a, C, NC, A> { /// # Arguments /// /// * `matchId` - The ID of the match. - pub fn rematch(&self, match_id: &str) -> TurnBasedMatcheRematchCall<'a, C, NC, A> { + pub fn rematch(&self, match_id: &str) -> TurnBasedMatcheRematchCall<'a, C, A> { TurnBasedMatcheRematchCall { hub: self.hub, _match_id: match_id.to_string(), @@ -3953,15 +3949,15 @@ impl<'a, C, NC, A> TurnBasedMatcheMethods<'a, C, NC, A> { /// let rb = hub.applications(); /// # } /// ``` -pub struct ApplicationMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ApplicationMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, } -impl<'a, C, NC, A> MethodsBuilder for ApplicationMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ApplicationMethods<'a, C, A> {} -impl<'a, C, NC, A> ApplicationMethods<'a, C, NC, A> { +impl<'a, C, A> ApplicationMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3970,7 +3966,7 @@ impl<'a, C, NC, A> ApplicationMethods<'a, C, NC, A> { /// # Arguments /// /// * `applicationId` - The application ID from the Google Play developer console. - pub fn get(&self, application_id: &str) -> ApplicationGetCall<'a, C, NC, A> { + pub fn get(&self, application_id: &str) -> ApplicationGetCall<'a, C, A> { ApplicationGetCall { hub: self.hub, _application_id: application_id.to_string(), @@ -3985,7 +3981,7 @@ impl<'a, C, NC, A> ApplicationMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Indicate that the the currently authenticated user is playing your application. - pub fn played(&self) -> ApplicationPlayedCall<'a, C, NC, A> { + pub fn played(&self) -> ApplicationPlayedCall<'a, C, A> { ApplicationPlayedCall { hub: self.hub, _delegate: Default::default(), @@ -4025,15 +4021,15 @@ impl<'a, C, NC, A> ApplicationMethods<'a, C, NC, A> { /// let rb = hub.rooms(); /// # } /// ``` -pub struct RoomMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RoomMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, } -impl<'a, C, NC, A> MethodsBuilder for RoomMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for RoomMethods<'a, C, A> {} -impl<'a, C, NC, A> RoomMethods<'a, C, NC, A> { +impl<'a, C, A> RoomMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -4042,7 +4038,7 @@ impl<'a, C, NC, A> RoomMethods<'a, C, NC, A> { /// # Arguments /// /// * `roomId` - The ID of the room. - pub fn get(&self, room_id: &str) -> RoomGetCall<'a, C, NC, A> { + pub fn get(&self, room_id: &str) -> RoomGetCall<'a, C, A> { RoomGetCall { hub: self.hub, _room_id: room_id.to_string(), @@ -4061,7 +4057,7 @@ impl<'a, C, NC, A> RoomMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `roomId` - The ID of the room. - pub fn leave(&self, request: &RoomLeaveRequest, room_id: &str) -> RoomLeaveCall<'a, C, NC, A> { + pub fn leave(&self, request: &RoomLeaveRequest, room_id: &str) -> RoomLeaveCall<'a, C, A> { RoomLeaveCall { hub: self.hub, _request: request.clone(), @@ -4076,7 +4072,7 @@ impl<'a, C, NC, A> RoomMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Returns invitations to join rooms. - pub fn list(&self) -> RoomListCall<'a, C, NC, A> { + pub fn list(&self) -> RoomListCall<'a, C, A> { RoomListCall { hub: self.hub, _page_token: Default::default(), @@ -4096,7 +4092,7 @@ impl<'a, C, NC, A> RoomMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `roomId` - The ID of the room. - pub fn report_status(&self, request: &RoomP2PStatuses, room_id: &str) -> RoomReportStatuCall<'a, C, NC, A> { + pub fn report_status(&self, request: &RoomP2PStatuses, room_id: &str) -> RoomReportStatuCall<'a, C, A> { RoomReportStatuCall { hub: self.hub, _request: request.clone(), @@ -4115,7 +4111,7 @@ impl<'a, C, NC, A> RoomMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn create(&self, request: &RoomCreateRequest) -> RoomCreateCall<'a, C, NC, A> { + pub fn create(&self, request: &RoomCreateRequest) -> RoomCreateCall<'a, C, A> { RoomCreateCall { hub: self.hub, _request: request.clone(), @@ -4133,7 +4129,7 @@ impl<'a, C, NC, A> RoomMethods<'a, C, NC, A> { /// # Arguments /// /// * `roomId` - The ID of the room. - pub fn decline(&self, room_id: &str) -> RoomDeclineCall<'a, C, NC, A> { + pub fn decline(&self, room_id: &str) -> RoomDeclineCall<'a, C, A> { RoomDeclineCall { hub: self.hub, _room_id: room_id.to_string(), @@ -4151,7 +4147,7 @@ impl<'a, C, NC, A> RoomMethods<'a, C, NC, A> { /// # Arguments /// /// * `roomId` - The ID of the room. - pub fn dismiss(&self, room_id: &str) -> RoomDismisCall<'a, C, NC, A> { + pub fn dismiss(&self, room_id: &str) -> RoomDismisCall<'a, C, A> { RoomDismisCall { hub: self.hub, _room_id: room_id.to_string(), @@ -4169,7 +4165,7 @@ impl<'a, C, NC, A> RoomMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `roomId` - The ID of the room. - pub fn join(&self, request: &RoomJoinRequest, room_id: &str) -> RoomJoinCall<'a, C, NC, A> { + pub fn join(&self, request: &RoomJoinRequest, room_id: &str) -> RoomJoinCall<'a, C, A> { RoomJoinCall { hub: self.hub, _request: request.clone(), @@ -4212,15 +4208,15 @@ impl<'a, C, NC, A> RoomMethods<'a, C, NC, A> { /// let rb = hub.scores(); /// # } /// ``` -pub struct ScoreMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ScoreMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, } -impl<'a, C, NC, A> MethodsBuilder for ScoreMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ScoreMethods<'a, C, A> {} -impl<'a, C, NC, A> ScoreMethods<'a, C, NC, A> { +impl<'a, C, A> ScoreMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -4230,7 +4226,7 @@ impl<'a, C, NC, A> ScoreMethods<'a, C, NC, A> { /// /// * `leaderboardId` - The ID of the leaderboard. /// * `score` - The score you're submitting. The submitted score is ignored if it is worse than a previously submitted score, where worse depends on the leaderboard sort order. The meaning of the score value depends on the leaderboard format type. For fixed-point, the score represents the raw value. For time, the score represents elapsed time in milliseconds. For currency, the score represents a value in micro units. - pub fn submit(&self, leaderboard_id: &str, score: &str) -> ScoreSubmitCall<'a, C, NC, A> { + pub fn submit(&self, leaderboard_id: &str, score: &str) -> ScoreSubmitCall<'a, C, A> { ScoreSubmitCall { hub: self.hub, _leaderboard_id: leaderboard_id.to_string(), @@ -4252,7 +4248,7 @@ impl<'a, C, NC, A> ScoreMethods<'a, C, NC, A> { /// * `leaderboardId` - The ID of the leaderboard. /// * `collection` - The collection of scores you're requesting. /// * `timeSpan` - The time span for the scores and ranks you're requesting. - pub fn list(&self, leaderboard_id: &str, collection: &str, time_span: &str) -> ScoreListCall<'a, C, NC, A> { + pub fn list(&self, leaderboard_id: &str, collection: &str, time_span: &str) -> ScoreListCall<'a, C, A> { ScoreListCall { hub: self.hub, _leaderboard_id: leaderboard_id.to_string(), @@ -4277,7 +4273,7 @@ impl<'a, C, NC, A> ScoreMethods<'a, C, NC, A> { /// * `playerId` - A player ID. A value of me may be used in place of the authenticated player's ID. /// * `leaderboardId` - The ID of the leaderboard. Can be set to 'ALL' to retrieve data for all leaderboards for this application. /// * `timeSpan` - The time span for the scores and ranks you're requesting. - pub fn get(&self, player_id: &str, leaderboard_id: &str, time_span: &str) -> ScoreGetCall<'a, C, NC, A> { + pub fn get(&self, player_id: &str, leaderboard_id: &str, time_span: &str) -> ScoreGetCall<'a, C, A> { ScoreGetCall { hub: self.hub, _player_id: player_id.to_string(), @@ -4300,7 +4296,7 @@ impl<'a, C, NC, A> ScoreMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn submit_multiple(&self, request: &PlayerScoreSubmissionList) -> ScoreSubmitMultipleCall<'a, C, NC, A> { + pub fn submit_multiple(&self, request: &PlayerScoreSubmissionList) -> ScoreSubmitMultipleCall<'a, C, A> { ScoreSubmitMultipleCall { hub: self.hub, _request: request.clone(), @@ -4320,7 +4316,7 @@ impl<'a, C, NC, A> ScoreMethods<'a, C, NC, A> { /// * `leaderboardId` - The ID of the leaderboard. /// * `collection` - The collection of scores you're requesting. /// * `timeSpan` - The time span for the scores and ranks you're requesting. - pub fn list_window(&self, leaderboard_id: &str, collection: &str, time_span: &str) -> ScoreListWindowCall<'a, C, NC, A> { + pub fn list_window(&self, leaderboard_id: &str, collection: &str, time_span: &str) -> ScoreListWindowCall<'a, C, A> { ScoreListWindowCall { hub: self.hub, _leaderboard_id: leaderboard_id.to_string(), @@ -4368,15 +4364,15 @@ impl<'a, C, NC, A> ScoreMethods<'a, C, NC, A> { /// let rb = hub.pushtokens(); /// # } /// ``` -pub struct PushtokenMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PushtokenMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, } -impl<'a, C, NC, A> MethodsBuilder for PushtokenMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PushtokenMethods<'a, C, A> {} -impl<'a, C, NC, A> PushtokenMethods<'a, C, NC, A> { +impl<'a, C, A> PushtokenMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -4385,7 +4381,7 @@ impl<'a, C, NC, A> PushtokenMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn remove(&self, request: &PushTokenId) -> PushtokenRemoveCall<'a, C, NC, A> { + pub fn remove(&self, request: &PushTokenId) -> PushtokenRemoveCall<'a, C, A> { PushtokenRemoveCall { hub: self.hub, _request: request.clone(), @@ -4402,7 +4398,7 @@ impl<'a, C, NC, A> PushtokenMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn update(&self, request: &PushToken) -> PushtokenUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &PushToken) -> PushtokenUpdateCall<'a, C, A> { PushtokenUpdateCall { hub: self.hub, _request: request.clone(), @@ -4443,15 +4439,15 @@ impl<'a, C, NC, A> PushtokenMethods<'a, C, NC, A> { /// let rb = hub.revisions(); /// # } /// ``` -pub struct RevisionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RevisionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, } -impl<'a, C, NC, A> MethodsBuilder for RevisionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for RevisionMethods<'a, C, A> {} -impl<'a, C, NC, A> RevisionMethods<'a, C, NC, A> { +impl<'a, C, A> RevisionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -4465,7 +4461,7 @@ impl<'a, C, NC, A> RevisionMethods<'a, C, NC, A> { /// - "ANDROID" - Client is running the Android SDK. /// - "IOS" - Client is running the iOS SDK. /// - "WEB_APP" - Client is running as a Web App. - pub fn check(&self, client_revision: &str) -> RevisionCheckCall<'a, C, NC, A> { + pub fn check(&self, client_revision: &str) -> RevisionCheckCall<'a, C, A> { RevisionCheckCall { hub: self.hub, _client_revision: client_revision.to_string(), @@ -4506,20 +4502,20 @@ impl<'a, C, NC, A> RevisionMethods<'a, C, NC, A> { /// let rb = hub.events(); /// # } /// ``` -pub struct EventMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, } -impl<'a, C, NC, A> MethodsBuilder for EventMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for EventMethods<'a, C, A> {} -impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { +impl<'a, C, A> EventMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Returns a list of the event definitions in this application. - pub fn list_definitions(&self) -> EventListDefinitionCall<'a, C, NC, A> { + pub fn list_definitions(&self) -> EventListDefinitionCall<'a, C, A> { EventListDefinitionCall { hub: self.hub, _page_token: Default::default(), @@ -4538,7 +4534,7 @@ impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn record(&self, request: &EventRecordRequest) -> EventRecordCall<'a, C, NC, A> { + pub fn record(&self, request: &EventRecordRequest) -> EventRecordCall<'a, C, A> { EventRecordCall { hub: self.hub, _request: request.clone(), @@ -4552,7 +4548,7 @@ impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Returns a list showing the current progress on events in this application for the currently authenticated user. - pub fn list_by_player(&self) -> EventListByPlayerCall<'a, C, NC, A> { + pub fn list_by_player(&self) -> EventListByPlayerCall<'a, C, A> { EventListByPlayerCall { hub: self.hub, _page_token: Default::default(), @@ -4595,15 +4591,15 @@ impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { /// let rb = hub.quest_milestones(); /// # } /// ``` -pub struct QuestMilestoneMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct QuestMilestoneMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, } -impl<'a, C, NC, A> MethodsBuilder for QuestMilestoneMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for QuestMilestoneMethods<'a, C, A> {} -impl<'a, C, NC, A> QuestMilestoneMethods<'a, C, NC, A> { +impl<'a, C, A> QuestMilestoneMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -4614,7 +4610,7 @@ impl<'a, C, NC, A> QuestMilestoneMethods<'a, C, NC, A> { /// * `questId` - The ID of the quest. /// * `milestoneId` - The ID of the milestone. /// * `requestId` - A numeric ID to ensure that the request is handled correctly across retries. Your client application must generate this ID randomly. - pub fn claim(&self, quest_id: &str, milestone_id: &str, request_id: &str) -> QuestMilestoneClaimCall<'a, C, NC, A> { + pub fn claim(&self, quest_id: &str, milestone_id: &str, request_id: &str) -> QuestMilestoneClaimCall<'a, C, A> { QuestMilestoneClaimCall { hub: self.hub, _quest_id: quest_id.to_string(), @@ -4657,20 +4653,20 @@ impl<'a, C, NC, A> QuestMilestoneMethods<'a, C, NC, A> { /// let rb = hub.achievement_definitions(); /// # } /// ``` -pub struct AchievementDefinitionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AchievementDefinitionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, } -impl<'a, C, NC, A> MethodsBuilder for AchievementDefinitionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AchievementDefinitionMethods<'a, C, A> {} -impl<'a, C, NC, A> AchievementDefinitionMethods<'a, C, NC, A> { +impl<'a, C, A> AchievementDefinitionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Lists all the achievement definitions for your application. - pub fn list(&self) -> AchievementDefinitionListCall<'a, C, NC, A> { + pub fn list(&self) -> AchievementDefinitionListCall<'a, C, A> { AchievementDefinitionListCall { hub: self.hub, _page_token: Default::default(), @@ -4725,10 +4721,10 @@ impl<'a, C, NC, A> AchievementDefinitionMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct AchievementListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AchievementListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _player_id: String, _state: Option, _page_token: Option, @@ -4739,9 +4735,9 @@ pub struct AchievementListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AchievementListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AchievementListCall<'a, C, A> {} -impl<'a, C, NC, A> AchievementListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AchievementListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4885,7 +4881,7 @@ impl<'a, C, NC, A> AchievementListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// A player ID. A value of me may be used in place of the authenticated player's ID. - pub fn player_id(mut self, new_value: &str) -> AchievementListCall<'a, C, NC, A> { + pub fn player_id(mut self, new_value: &str) -> AchievementListCall<'a, C, A> { self._player_id = new_value.to_string(); self } @@ -4893,7 +4889,7 @@ impl<'a, C, NC, A> AchievementListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Tells the server to return only achievements with the specified state. If this parameter isn't specified, all achievements are returned. - pub fn state(mut self, new_value: &str) -> AchievementListCall<'a, C, NC, A> { + pub fn state(mut self, new_value: &str) -> AchievementListCall<'a, C, A> { self._state = Some(new_value.to_string()); self } @@ -4901,7 +4897,7 @@ impl<'a, C, NC, A> AchievementListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> AchievementListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AchievementListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -4909,7 +4905,7 @@ impl<'a, C, NC, A> AchievementListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The maximum number of achievement resources to return in the response, used for paging. For any response, the actual number of achievement resources returned may be less than the specified maxResults. - pub fn max_results(mut self, new_value: i32) -> AchievementListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AchievementListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -4917,7 +4913,7 @@ impl<'a, C, NC, A> AchievementListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> AchievementListCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> AchievementListCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -4928,7 +4924,7 @@ impl<'a, C, NC, A> AchievementListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4949,7 +4945,7 @@ impl<'a, C, NC, A> AchievementListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AchievementListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AchievementListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4966,7 +4962,7 @@ impl<'a, C, NC, A> AchievementListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AchievementListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AchievementListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5005,10 +5001,10 @@ impl<'a, C, NC, A> AchievementListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct AchievementIncrementCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AchievementIncrementCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _achievement_id: String, _steps_to_increment: i32, _request_id: Option, @@ -5017,9 +5013,9 @@ pub struct AchievementIncrementCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AchievementIncrementCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AchievementIncrementCall<'a, C, A> {} -impl<'a, C, NC, A> AchievementIncrementCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AchievementIncrementCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5155,7 +5151,7 @@ impl<'a, C, NC, A> AchievementIncrementCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The ID of the achievement used by this method. - pub fn achievement_id(mut self, new_value: &str) -> AchievementIncrementCall<'a, C, NC, A> { + pub fn achievement_id(mut self, new_value: &str) -> AchievementIncrementCall<'a, C, A> { self._achievement_id = new_value.to_string(); self } @@ -5165,7 +5161,7 @@ impl<'a, C, NC, A> AchievementIncrementCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The number of steps to increment. - pub fn steps_to_increment(mut self, new_value: i32) -> AchievementIncrementCall<'a, C, NC, A> { + pub fn steps_to_increment(mut self, new_value: i32) -> AchievementIncrementCall<'a, C, A> { self._steps_to_increment = new_value; self } @@ -5173,7 +5169,7 @@ impl<'a, C, NC, A> AchievementIncrementCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// A randomly generated numeric ID for each request specified by the caller. This number is used at the server to ensure that the request is handled correctly across retries. - pub fn request_id(mut self, new_value: &str) -> AchievementIncrementCall<'a, C, NC, A> { + pub fn request_id(mut self, new_value: &str) -> AchievementIncrementCall<'a, C, A> { self._request_id = Some(new_value.to_string()); self } @@ -5184,7 +5180,7 @@ impl<'a, C, NC, A> AchievementIncrementCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementIncrementCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementIncrementCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5205,7 +5201,7 @@ impl<'a, C, NC, A> AchievementIncrementCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AchievementIncrementCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AchievementIncrementCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5222,7 +5218,7 @@ impl<'a, C, NC, A> AchievementIncrementCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AchievementIncrementCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AchievementIncrementCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5260,10 +5256,10 @@ impl<'a, C, NC, A> AchievementIncrementCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct AchievementSetStepsAtLeastCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AchievementSetStepsAtLeastCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _achievement_id: String, _steps: i32, _delegate: Option<&'a mut Delegate>, @@ -5271,9 +5267,9 @@ pub struct AchievementSetStepsAtLeastCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AchievementSetStepsAtLeastCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AchievementSetStepsAtLeastCall<'a, C, A> {} -impl<'a, C, NC, A> AchievementSetStepsAtLeastCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AchievementSetStepsAtLeastCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5406,7 +5402,7 @@ impl<'a, C, NC, A> AchievementSetStepsAtLeastCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The ID of the achievement used by this method. - pub fn achievement_id(mut self, new_value: &str) -> AchievementSetStepsAtLeastCall<'a, C, NC, A> { + pub fn achievement_id(mut self, new_value: &str) -> AchievementSetStepsAtLeastCall<'a, C, A> { self._achievement_id = new_value.to_string(); self } @@ -5416,7 +5412,7 @@ impl<'a, C, NC, A> AchievementSetStepsAtLeastCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The minimum value to set the steps to. - pub fn steps(mut self, new_value: i32) -> AchievementSetStepsAtLeastCall<'a, C, NC, A> { + pub fn steps(mut self, new_value: i32) -> AchievementSetStepsAtLeastCall<'a, C, A> { self._steps = new_value; self } @@ -5427,7 +5423,7 @@ impl<'a, C, NC, A> AchievementSetStepsAtLeastCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementSetStepsAtLeastCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementSetStepsAtLeastCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5448,7 +5444,7 @@ impl<'a, C, NC, A> AchievementSetStepsAtLeastCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AchievementSetStepsAtLeastCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AchievementSetStepsAtLeastCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5465,7 +5461,7 @@ impl<'a, C, NC, A> AchievementSetStepsAtLeastCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AchievementSetStepsAtLeastCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AchievementSetStepsAtLeastCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5509,19 +5505,19 @@ impl<'a, C, NC, A> AchievementSetStepsAtLeastCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct AchievementUpdateMultipleCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AchievementUpdateMultipleCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _request: AchievementUpdateMultipleRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AchievementUpdateMultipleCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AchievementUpdateMultipleCall<'a, C, A> {} -impl<'a, C, NC, A> AchievementUpdateMultipleCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AchievementUpdateMultipleCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5635,7 +5631,7 @@ impl<'a, C, NC, A> AchievementUpdateMultipleCall<'a, C, NC, A> where NC: hyper:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AchievementUpdateMultipleRequest) -> AchievementUpdateMultipleCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AchievementUpdateMultipleRequest) -> AchievementUpdateMultipleCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5646,7 +5642,7 @@ impl<'a, C, NC, A> AchievementUpdateMultipleCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementUpdateMultipleCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementUpdateMultipleCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5667,7 +5663,7 @@ impl<'a, C, NC, A> AchievementUpdateMultipleCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AchievementUpdateMultipleCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AchievementUpdateMultipleCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5684,7 +5680,7 @@ impl<'a, C, NC, A> AchievementUpdateMultipleCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AchievementUpdateMultipleCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AchievementUpdateMultipleCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5722,19 +5718,19 @@ impl<'a, C, NC, A> AchievementUpdateMultipleCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct AchievementRevealCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AchievementRevealCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _achievement_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AchievementRevealCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AchievementRevealCall<'a, C, A> {} -impl<'a, C, NC, A> AchievementRevealCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AchievementRevealCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5866,7 +5862,7 @@ impl<'a, C, NC, A> AchievementRevealCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the achievement used by this method. - pub fn achievement_id(mut self, new_value: &str) -> AchievementRevealCall<'a, C, NC, A> { + pub fn achievement_id(mut self, new_value: &str) -> AchievementRevealCall<'a, C, A> { self._achievement_id = new_value.to_string(); self } @@ -5877,7 +5873,7 @@ impl<'a, C, NC, A> AchievementRevealCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementRevealCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementRevealCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5898,7 +5894,7 @@ impl<'a, C, NC, A> AchievementRevealCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AchievementRevealCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AchievementRevealCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5915,7 +5911,7 @@ impl<'a, C, NC, A> AchievementRevealCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AchievementRevealCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AchievementRevealCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5953,19 +5949,19 @@ impl<'a, C, NC, A> AchievementRevealCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct AchievementUnlockCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AchievementUnlockCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _achievement_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AchievementUnlockCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AchievementUnlockCall<'a, C, A> {} -impl<'a, C, NC, A> AchievementUnlockCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AchievementUnlockCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6097,7 +6093,7 @@ impl<'a, C, NC, A> AchievementUnlockCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the achievement used by this method. - pub fn achievement_id(mut self, new_value: &str) -> AchievementUnlockCall<'a, C, NC, A> { + pub fn achievement_id(mut self, new_value: &str) -> AchievementUnlockCall<'a, C, A> { self._achievement_id = new_value.to_string(); self } @@ -6108,7 +6104,7 @@ impl<'a, C, NC, A> AchievementUnlockCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementUnlockCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementUnlockCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6129,7 +6125,7 @@ impl<'a, C, NC, A> AchievementUnlockCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AchievementUnlockCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AchievementUnlockCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6146,7 +6142,7 @@ impl<'a, C, NC, A> AchievementUnlockCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AchievementUnlockCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AchievementUnlockCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6185,10 +6181,10 @@ impl<'a, C, NC, A> AchievementUnlockCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct LeaderboardGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LeaderboardGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _leaderboard_id: String, _language: Option, _delegate: Option<&'a mut Delegate>, @@ -6196,9 +6192,9 @@ pub struct LeaderboardGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LeaderboardGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LeaderboardGetCall<'a, C, A> {} -impl<'a, C, NC, A> LeaderboardGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LeaderboardGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6333,7 +6329,7 @@ impl<'a, C, NC, A> LeaderboardGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the leaderboard. - pub fn leaderboard_id(mut self, new_value: &str) -> LeaderboardGetCall<'a, C, NC, A> { + pub fn leaderboard_id(mut self, new_value: &str) -> LeaderboardGetCall<'a, C, A> { self._leaderboard_id = new_value.to_string(); self } @@ -6341,7 +6337,7 @@ impl<'a, C, NC, A> LeaderboardGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> LeaderboardGetCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> LeaderboardGetCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -6352,7 +6348,7 @@ impl<'a, C, NC, A> LeaderboardGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LeaderboardGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LeaderboardGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6373,7 +6369,7 @@ impl<'a, C, NC, A> LeaderboardGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LeaderboardGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LeaderboardGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6390,7 +6386,7 @@ impl<'a, C, NC, A> LeaderboardGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LeaderboardGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LeaderboardGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6431,10 +6427,10 @@ impl<'a, C, NC, A> LeaderboardGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct LeaderboardListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LeaderboardListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _page_token: Option, _max_results: Option, _language: Option, @@ -6443,9 +6439,9 @@ pub struct LeaderboardListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LeaderboardListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LeaderboardListCall<'a, C, A> {} -impl<'a, C, NC, A> LeaderboardListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LeaderboardListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6559,7 +6555,7 @@ impl<'a, C, NC, A> LeaderboardListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> LeaderboardListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> LeaderboardListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -6567,7 +6563,7 @@ impl<'a, C, NC, A> LeaderboardListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The maximum number of leaderboards to return in the response. For any response, the actual number of leaderboards returned may be less than the specified maxResults. - pub fn max_results(mut self, new_value: i32) -> LeaderboardListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> LeaderboardListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -6575,7 +6571,7 @@ impl<'a, C, NC, A> LeaderboardListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> LeaderboardListCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> LeaderboardListCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -6586,7 +6582,7 @@ impl<'a, C, NC, A> LeaderboardListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LeaderboardListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LeaderboardListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6607,7 +6603,7 @@ impl<'a, C, NC, A> LeaderboardListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LeaderboardListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LeaderboardListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6624,7 +6620,7 @@ impl<'a, C, NC, A> LeaderboardListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LeaderboardListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LeaderboardListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6665,10 +6661,10 @@ impl<'a, C, NC, A> LeaderboardListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct MetagameListCategoriesByPlayerCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MetagameListCategoriesByPlayerCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _player_id: String, _collection: String, _page_token: Option, @@ -6679,9 +6675,9 @@ pub struct MetagameListCategoriesByPlayerCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MetagameListCategoriesByPlayerCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MetagameListCategoriesByPlayerCall<'a, C, A> {} -impl<'a, C, NC, A> MetagameListCategoriesByPlayerCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MetagameListCategoriesByPlayerCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6823,7 +6819,7 @@ impl<'a, C, NC, A> MetagameListCategoriesByPlayerCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// A player ID. A value of me may be used in place of the authenticated player's ID. - pub fn player_id(mut self, new_value: &str) -> MetagameListCategoriesByPlayerCall<'a, C, NC, A> { + pub fn player_id(mut self, new_value: &str) -> MetagameListCategoriesByPlayerCall<'a, C, A> { self._player_id = new_value.to_string(); self } @@ -6833,7 +6829,7 @@ impl<'a, C, NC, A> MetagameListCategoriesByPlayerCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// The collection of categories for which data will be returned. - pub fn collection(mut self, new_value: &str) -> MetagameListCategoriesByPlayerCall<'a, C, NC, A> { + pub fn collection(mut self, new_value: &str) -> MetagameListCategoriesByPlayerCall<'a, C, A> { self._collection = new_value.to_string(); self } @@ -6841,7 +6837,7 @@ impl<'a, C, NC, A> MetagameListCategoriesByPlayerCall<'a, C, NC, A> where NC: hy /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> MetagameListCategoriesByPlayerCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> MetagameListCategoriesByPlayerCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -6849,7 +6845,7 @@ impl<'a, C, NC, A> MetagameListCategoriesByPlayerCall<'a, C, NC, A> where NC: hy /// /// /// The maximum number of category resources to return in the response, used for paging. For any response, the actual number of category resources returned may be less than the specified maxResults. - pub fn max_results(mut self, new_value: i32) -> MetagameListCategoriesByPlayerCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> MetagameListCategoriesByPlayerCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -6857,7 +6853,7 @@ impl<'a, C, NC, A> MetagameListCategoriesByPlayerCall<'a, C, NC, A> where NC: hy /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> MetagameListCategoriesByPlayerCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> MetagameListCategoriesByPlayerCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -6868,7 +6864,7 @@ impl<'a, C, NC, A> MetagameListCategoriesByPlayerCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MetagameListCategoriesByPlayerCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MetagameListCategoriesByPlayerCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6889,7 +6885,7 @@ impl<'a, C, NC, A> MetagameListCategoriesByPlayerCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MetagameListCategoriesByPlayerCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MetagameListCategoriesByPlayerCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6906,7 +6902,7 @@ impl<'a, C, NC, A> MetagameListCategoriesByPlayerCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MetagameListCategoriesByPlayerCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MetagameListCategoriesByPlayerCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6944,18 +6940,18 @@ impl<'a, C, NC, A> MetagameListCategoriesByPlayerCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct MetagameGetMetagameConfigCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MetagameGetMetagameConfigCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MetagameGetMetagameConfigCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MetagameGetMetagameConfigCall<'a, C, A> {} -impl<'a, C, NC, A> MetagameGetMetagameConfigCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MetagameGetMetagameConfigCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7063,7 +7059,7 @@ impl<'a, C, NC, A> MetagameGetMetagameConfigCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MetagameGetMetagameConfigCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MetagameGetMetagameConfigCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7084,7 +7080,7 @@ impl<'a, C, NC, A> MetagameGetMetagameConfigCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MetagameGetMetagameConfigCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MetagameGetMetagameConfigCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7101,7 +7097,7 @@ impl<'a, C, NC, A> MetagameGetMetagameConfigCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MetagameGetMetagameConfigCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MetagameGetMetagameConfigCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7142,10 +7138,10 @@ impl<'a, C, NC, A> MetagameGetMetagameConfigCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct PlayerListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlayerListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _collection: String, _page_token: Option, _max_results: Option, @@ -7155,9 +7151,9 @@ pub struct PlayerListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlayerListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlayerListCall<'a, C, A> {} -impl<'a, C, NC, A> PlayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlayerListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7298,7 +7294,7 @@ impl<'a, C, NC, A> PlayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Collection of players being retrieved - pub fn collection(mut self, new_value: &str) -> PlayerListCall<'a, C, NC, A> { + pub fn collection(mut self, new_value: &str) -> PlayerListCall<'a, C, A> { self._collection = new_value.to_string(); self } @@ -7306,7 +7302,7 @@ impl<'a, C, NC, A> PlayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> PlayerListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> PlayerListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -7314,7 +7310,7 @@ impl<'a, C, NC, A> PlayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The maximum number of player resources to return in the response, used for paging. For any response, the actual number of player resources returned may be less than the specified maxResults. - pub fn max_results(mut self, new_value: i32) -> PlayerListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> PlayerListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -7322,7 +7318,7 @@ impl<'a, C, NC, A> PlayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> PlayerListCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> PlayerListCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -7333,7 +7329,7 @@ impl<'a, C, NC, A> PlayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlayerListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlayerListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7354,7 +7350,7 @@ impl<'a, C, NC, A> PlayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlayerListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlayerListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7371,7 +7367,7 @@ impl<'a, C, NC, A> PlayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlayerListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlayerListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7410,10 +7406,10 @@ impl<'a, C, NC, A> PlayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct PlayerGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlayerGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _player_id: String, _language: Option, _delegate: Option<&'a mut Delegate>, @@ -7421,9 +7417,9 @@ pub struct PlayerGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlayerGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlayerGetCall<'a, C, A> {} -impl<'a, C, NC, A> PlayerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlayerGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7558,7 +7554,7 @@ impl<'a, C, NC, A> PlayerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// A player ID. A value of me may be used in place of the authenticated player's ID. - pub fn player_id(mut self, new_value: &str) -> PlayerGetCall<'a, C, NC, A> { + pub fn player_id(mut self, new_value: &str) -> PlayerGetCall<'a, C, A> { self._player_id = new_value.to_string(); self } @@ -7566,7 +7562,7 @@ impl<'a, C, NC, A> PlayerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> PlayerGetCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> PlayerGetCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -7577,7 +7573,7 @@ impl<'a, C, NC, A> PlayerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlayerGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlayerGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7598,7 +7594,7 @@ impl<'a, C, NC, A> PlayerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlayerGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlayerGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7615,7 +7611,7 @@ impl<'a, C, NC, A> PlayerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlayerGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlayerGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7654,10 +7650,10 @@ impl<'a, C, NC, A> PlayerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct QuestAcceptCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct QuestAcceptCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _quest_id: String, _language: Option, _delegate: Option<&'a mut Delegate>, @@ -7665,9 +7661,9 @@ pub struct QuestAcceptCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for QuestAcceptCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for QuestAcceptCall<'a, C, A> {} -impl<'a, C, NC, A> QuestAcceptCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> QuestAcceptCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7802,7 +7798,7 @@ impl<'a, C, NC, A> QuestAcceptCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the quest. - pub fn quest_id(mut self, new_value: &str) -> QuestAcceptCall<'a, C, NC, A> { + pub fn quest_id(mut self, new_value: &str) -> QuestAcceptCall<'a, C, A> { self._quest_id = new_value.to_string(); self } @@ -7810,7 +7806,7 @@ impl<'a, C, NC, A> QuestAcceptCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> QuestAcceptCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> QuestAcceptCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -7821,7 +7817,7 @@ impl<'a, C, NC, A> QuestAcceptCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> QuestAcceptCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> QuestAcceptCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7842,7 +7838,7 @@ impl<'a, C, NC, A> QuestAcceptCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> QuestAcceptCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> QuestAcceptCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7859,7 +7855,7 @@ impl<'a, C, NC, A> QuestAcceptCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> QuestAcceptCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> QuestAcceptCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7900,10 +7896,10 @@ impl<'a, C, NC, A> QuestAcceptCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct QuestListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct QuestListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _player_id: String, _page_token: Option, _max_results: Option, @@ -7913,9 +7909,9 @@ pub struct QuestListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for QuestListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for QuestListCall<'a, C, A> {} -impl<'a, C, NC, A> QuestListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> QuestListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8056,7 +8052,7 @@ impl<'a, C, NC, A> QuestListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// A player ID. A value of me may be used in place of the authenticated player's ID. - pub fn player_id(mut self, new_value: &str) -> QuestListCall<'a, C, NC, A> { + pub fn player_id(mut self, new_value: &str) -> QuestListCall<'a, C, A> { self._player_id = new_value.to_string(); self } @@ -8064,7 +8060,7 @@ impl<'a, C, NC, A> QuestListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> QuestListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> QuestListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -8072,7 +8068,7 @@ impl<'a, C, NC, A> QuestListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The maximum number of quest resources to return in the response, used for paging. For any response, the actual number of quest resources returned may be less than the specified maxResults. Acceptable values are 1 to 50, inclusive. (Default: 50). - pub fn max_results(mut self, new_value: i32) -> QuestListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> QuestListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -8080,7 +8076,7 @@ impl<'a, C, NC, A> QuestListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> QuestListCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> QuestListCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -8091,7 +8087,7 @@ impl<'a, C, NC, A> QuestListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> QuestListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> QuestListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8112,7 +8108,7 @@ impl<'a, C, NC, A> QuestListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> QuestListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> QuestListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8129,7 +8125,7 @@ impl<'a, C, NC, A> QuestListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> QuestListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> QuestListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8168,10 +8164,10 @@ impl<'a, C, NC, A> QuestListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct SnapshotGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SnapshotGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _snapshot_id: String, _language: Option, _delegate: Option<&'a mut Delegate>, @@ -8179,9 +8175,9 @@ pub struct SnapshotGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SnapshotGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SnapshotGetCall<'a, C, A> {} -impl<'a, C, NC, A> SnapshotGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SnapshotGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8316,7 +8312,7 @@ impl<'a, C, NC, A> SnapshotGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the snapshot. - pub fn snapshot_id(mut self, new_value: &str) -> SnapshotGetCall<'a, C, NC, A> { + pub fn snapshot_id(mut self, new_value: &str) -> SnapshotGetCall<'a, C, A> { self._snapshot_id = new_value.to_string(); self } @@ -8324,7 +8320,7 @@ impl<'a, C, NC, A> SnapshotGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> SnapshotGetCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> SnapshotGetCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -8335,7 +8331,7 @@ impl<'a, C, NC, A> SnapshotGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SnapshotGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SnapshotGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8356,7 +8352,7 @@ impl<'a, C, NC, A> SnapshotGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SnapshotGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SnapshotGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8373,7 +8369,7 @@ impl<'a, C, NC, A> SnapshotGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SnapshotGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SnapshotGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8414,10 +8410,10 @@ impl<'a, C, NC, A> SnapshotGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct SnapshotListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SnapshotListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _player_id: String, _page_token: Option, _max_results: Option, @@ -8427,9 +8423,9 @@ pub struct SnapshotListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SnapshotListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SnapshotListCall<'a, C, A> {} -impl<'a, C, NC, A> SnapshotListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SnapshotListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8570,7 +8566,7 @@ impl<'a, C, NC, A> SnapshotListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// A player ID. A value of me may be used in place of the authenticated player's ID. - pub fn player_id(mut self, new_value: &str) -> SnapshotListCall<'a, C, NC, A> { + pub fn player_id(mut self, new_value: &str) -> SnapshotListCall<'a, C, A> { self._player_id = new_value.to_string(); self } @@ -8578,7 +8574,7 @@ impl<'a, C, NC, A> SnapshotListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> SnapshotListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> SnapshotListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -8586,7 +8582,7 @@ impl<'a, C, NC, A> SnapshotListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The maximum number of snapshot resources to return in the response, used for paging. For any response, the actual number of snapshot resources returned may be less than the specified maxResults. - pub fn max_results(mut self, new_value: i32) -> SnapshotListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> SnapshotListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -8594,7 +8590,7 @@ impl<'a, C, NC, A> SnapshotListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> SnapshotListCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> SnapshotListCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -8605,7 +8601,7 @@ impl<'a, C, NC, A> SnapshotListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SnapshotListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SnapshotListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8626,7 +8622,7 @@ impl<'a, C, NC, A> SnapshotListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SnapshotListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SnapshotListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8643,7 +8639,7 @@ impl<'a, C, NC, A> SnapshotListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SnapshotListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SnapshotListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8681,19 +8677,19 @@ impl<'a, C, NC, A> SnapshotListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct TurnBasedMatcheDismisCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TurnBasedMatcheDismisCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _match_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TurnBasedMatcheDismisCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TurnBasedMatcheDismisCall<'a, C, A> {} -impl<'a, C, NC, A> TurnBasedMatcheDismisCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TurnBasedMatcheDismisCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8814,7 +8810,7 @@ impl<'a, C, NC, A> TurnBasedMatcheDismisCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The ID of the match. - pub fn match_id(mut self, new_value: &str) -> TurnBasedMatcheDismisCall<'a, C, NC, A> { + pub fn match_id(mut self, new_value: &str) -> TurnBasedMatcheDismisCall<'a, C, A> { self._match_id = new_value.to_string(); self } @@ -8825,7 +8821,7 @@ impl<'a, C, NC, A> TurnBasedMatcheDismisCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheDismisCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheDismisCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8846,7 +8842,7 @@ impl<'a, C, NC, A> TurnBasedMatcheDismisCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheDismisCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheDismisCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8863,7 +8859,7 @@ impl<'a, C, NC, A> TurnBasedMatcheDismisCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheDismisCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheDismisCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8906,10 +8902,10 @@ impl<'a, C, NC, A> TurnBasedMatcheDismisCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct TurnBasedMatcheSyncCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TurnBasedMatcheSyncCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _page_token: Option, _max_results: Option, _max_completed_matches: Option, @@ -8920,9 +8916,9 @@ pub struct TurnBasedMatcheSyncCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TurnBasedMatcheSyncCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TurnBasedMatcheSyncCall<'a, C, A> {} -impl<'a, C, NC, A> TurnBasedMatcheSyncCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TurnBasedMatcheSyncCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9042,7 +9038,7 @@ impl<'a, C, NC, A> TurnBasedMatcheSyncCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> TurnBasedMatcheSyncCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TurnBasedMatcheSyncCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -9050,7 +9046,7 @@ impl<'a, C, NC, A> TurnBasedMatcheSyncCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The maximum number of matches to return in the response, used for paging. For any response, the actual number of matches to return may be less than the specified maxResults. - pub fn max_results(mut self, new_value: i32) -> TurnBasedMatcheSyncCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> TurnBasedMatcheSyncCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -9058,7 +9054,7 @@ impl<'a, C, NC, A> TurnBasedMatcheSyncCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The maximum number of completed or canceled matches to return in the response. If not set, all matches returned could be completed or canceled. - pub fn max_completed_matches(mut self, new_value: i32) -> TurnBasedMatcheSyncCall<'a, C, NC, A> { + pub fn max_completed_matches(mut self, new_value: i32) -> TurnBasedMatcheSyncCall<'a, C, A> { self._max_completed_matches = Some(new_value); self } @@ -9066,7 +9062,7 @@ impl<'a, C, NC, A> TurnBasedMatcheSyncCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> TurnBasedMatcheSyncCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> TurnBasedMatcheSyncCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -9074,7 +9070,7 @@ impl<'a, C, NC, A> TurnBasedMatcheSyncCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// True if match data should be returned in the response. Note that not all data will necessarily be returned if include_match_data is true; the server may decide to only return data for some of the matches to limit download size for the client. The remainder of the data for these matches will be retrievable on request. - pub fn include_match_data(mut self, new_value: bool) -> TurnBasedMatcheSyncCall<'a, C, NC, A> { + pub fn include_match_data(mut self, new_value: bool) -> TurnBasedMatcheSyncCall<'a, C, A> { self._include_match_data = Some(new_value); self } @@ -9085,7 +9081,7 @@ impl<'a, C, NC, A> TurnBasedMatcheSyncCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheSyncCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheSyncCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9106,7 +9102,7 @@ impl<'a, C, NC, A> TurnBasedMatcheSyncCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheSyncCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheSyncCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9123,7 +9119,7 @@ impl<'a, C, NC, A> TurnBasedMatcheSyncCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheSyncCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheSyncCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9162,10 +9158,10 @@ impl<'a, C, NC, A> TurnBasedMatcheSyncCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct TurnBasedMatcheDeclineCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TurnBasedMatcheDeclineCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _match_id: String, _language: Option, _delegate: Option<&'a mut Delegate>, @@ -9173,9 +9169,9 @@ pub struct TurnBasedMatcheDeclineCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TurnBasedMatcheDeclineCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TurnBasedMatcheDeclineCall<'a, C, A> {} -impl<'a, C, NC, A> TurnBasedMatcheDeclineCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TurnBasedMatcheDeclineCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9310,7 +9306,7 @@ impl<'a, C, NC, A> TurnBasedMatcheDeclineCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The ID of the match. - pub fn match_id(mut self, new_value: &str) -> TurnBasedMatcheDeclineCall<'a, C, NC, A> { + pub fn match_id(mut self, new_value: &str) -> TurnBasedMatcheDeclineCall<'a, C, A> { self._match_id = new_value.to_string(); self } @@ -9318,7 +9314,7 @@ impl<'a, C, NC, A> TurnBasedMatcheDeclineCall<'a, C, NC, A> where NC: hyper::net /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> TurnBasedMatcheDeclineCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> TurnBasedMatcheDeclineCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -9329,7 +9325,7 @@ impl<'a, C, NC, A> TurnBasedMatcheDeclineCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheDeclineCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheDeclineCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9350,7 +9346,7 @@ impl<'a, C, NC, A> TurnBasedMatcheDeclineCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheDeclineCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheDeclineCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9367,7 +9363,7 @@ impl<'a, C, NC, A> TurnBasedMatcheDeclineCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheDeclineCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheDeclineCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9407,10 +9403,10 @@ impl<'a, C, NC, A> TurnBasedMatcheDeclineCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct TurnBasedMatcheGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TurnBasedMatcheGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _match_id: String, _language: Option, _include_match_data: Option, @@ -9419,9 +9415,9 @@ pub struct TurnBasedMatcheGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TurnBasedMatcheGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TurnBasedMatcheGetCall<'a, C, A> {} -impl<'a, C, NC, A> TurnBasedMatcheGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TurnBasedMatcheGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9559,7 +9555,7 @@ impl<'a, C, NC, A> TurnBasedMatcheGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The ID of the match. - pub fn match_id(mut self, new_value: &str) -> TurnBasedMatcheGetCall<'a, C, NC, A> { + pub fn match_id(mut self, new_value: &str) -> TurnBasedMatcheGetCall<'a, C, A> { self._match_id = new_value.to_string(); self } @@ -9567,7 +9563,7 @@ impl<'a, C, NC, A> TurnBasedMatcheGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> TurnBasedMatcheGetCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> TurnBasedMatcheGetCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -9575,7 +9571,7 @@ impl<'a, C, NC, A> TurnBasedMatcheGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Get match data along with metadata. - pub fn include_match_data(mut self, new_value: bool) -> TurnBasedMatcheGetCall<'a, C, NC, A> { + pub fn include_match_data(mut self, new_value: bool) -> TurnBasedMatcheGetCall<'a, C, A> { self._include_match_data = Some(new_value); self } @@ -9586,7 +9582,7 @@ impl<'a, C, NC, A> TurnBasedMatcheGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9607,7 +9603,7 @@ impl<'a, C, NC, A> TurnBasedMatcheGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9624,7 +9620,7 @@ impl<'a, C, NC, A> TurnBasedMatcheGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9669,10 +9665,10 @@ impl<'a, C, NC, A> TurnBasedMatcheGetCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct TurnBasedMatcheCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TurnBasedMatcheCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _request: TurnBasedMatchCreateRequest, _language: Option, _delegate: Option<&'a mut Delegate>, @@ -9680,9 +9676,9 @@ pub struct TurnBasedMatcheCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TurnBasedMatcheCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TurnBasedMatcheCreateCall<'a, C, A> {} -impl<'a, C, NC, A> TurnBasedMatcheCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TurnBasedMatcheCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9799,7 +9795,7 @@ impl<'a, C, NC, A> TurnBasedMatcheCreateCall<'a, C, NC, A> where NC: hyper::net: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &TurnBasedMatchCreateRequest) -> TurnBasedMatcheCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &TurnBasedMatchCreateRequest) -> TurnBasedMatcheCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9807,7 +9803,7 @@ impl<'a, C, NC, A> TurnBasedMatcheCreateCall<'a, C, NC, A> where NC: hyper::net: /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> TurnBasedMatcheCreateCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> TurnBasedMatcheCreateCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -9818,7 +9814,7 @@ impl<'a, C, NC, A> TurnBasedMatcheCreateCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9839,7 +9835,7 @@ impl<'a, C, NC, A> TurnBasedMatcheCreateCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9856,7 +9852,7 @@ impl<'a, C, NC, A> TurnBasedMatcheCreateCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9895,10 +9891,10 @@ impl<'a, C, NC, A> TurnBasedMatcheCreateCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct TurnBasedMatcheJoinCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TurnBasedMatcheJoinCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _match_id: String, _language: Option, _delegate: Option<&'a mut Delegate>, @@ -9906,9 +9902,9 @@ pub struct TurnBasedMatcheJoinCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TurnBasedMatcheJoinCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TurnBasedMatcheJoinCall<'a, C, A> {} -impl<'a, C, NC, A> TurnBasedMatcheJoinCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TurnBasedMatcheJoinCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10043,7 +10039,7 @@ impl<'a, C, NC, A> TurnBasedMatcheJoinCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The ID of the match. - pub fn match_id(mut self, new_value: &str) -> TurnBasedMatcheJoinCall<'a, C, NC, A> { + pub fn match_id(mut self, new_value: &str) -> TurnBasedMatcheJoinCall<'a, C, A> { self._match_id = new_value.to_string(); self } @@ -10051,7 +10047,7 @@ impl<'a, C, NC, A> TurnBasedMatcheJoinCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> TurnBasedMatcheJoinCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> TurnBasedMatcheJoinCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -10062,7 +10058,7 @@ impl<'a, C, NC, A> TurnBasedMatcheJoinCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheJoinCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheJoinCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10083,7 +10079,7 @@ impl<'a, C, NC, A> TurnBasedMatcheJoinCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheJoinCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheJoinCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10100,7 +10096,7 @@ impl<'a, C, NC, A> TurnBasedMatcheJoinCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheJoinCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheJoinCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10140,10 +10136,10 @@ impl<'a, C, NC, A> TurnBasedMatcheJoinCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct TurnBasedMatcheLeaveTurnCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TurnBasedMatcheLeaveTurnCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _match_id: String, _match_version: i32, _pending_participant_id: Option, @@ -10153,9 +10149,9 @@ pub struct TurnBasedMatcheLeaveTurnCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TurnBasedMatcheLeaveTurnCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TurnBasedMatcheLeaveTurnCall<'a, C, A> {} -impl<'a, C, NC, A> TurnBasedMatcheLeaveTurnCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TurnBasedMatcheLeaveTurnCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10294,7 +10290,7 @@ impl<'a, C, NC, A> TurnBasedMatcheLeaveTurnCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The ID of the match. - pub fn match_id(mut self, new_value: &str) -> TurnBasedMatcheLeaveTurnCall<'a, C, NC, A> { + pub fn match_id(mut self, new_value: &str) -> TurnBasedMatcheLeaveTurnCall<'a, C, A> { self._match_id = new_value.to_string(); self } @@ -10304,7 +10300,7 @@ impl<'a, C, NC, A> TurnBasedMatcheLeaveTurnCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The version of the match being updated. - pub fn match_version(mut self, new_value: i32) -> TurnBasedMatcheLeaveTurnCall<'a, C, NC, A> { + pub fn match_version(mut self, new_value: i32) -> TurnBasedMatcheLeaveTurnCall<'a, C, A> { self._match_version = new_value; self } @@ -10312,7 +10308,7 @@ impl<'a, C, NC, A> TurnBasedMatcheLeaveTurnCall<'a, C, NC, A> where NC: hyper::n /// /// /// The ID of another participant who should take their turn next. If not set, the match will wait for other player(s) to join via automatching; this is only valid if automatch criteria is set on the match with remaining slots for automatched players. - pub fn pending_participant_id(mut self, new_value: &str) -> TurnBasedMatcheLeaveTurnCall<'a, C, NC, A> { + pub fn pending_participant_id(mut self, new_value: &str) -> TurnBasedMatcheLeaveTurnCall<'a, C, A> { self._pending_participant_id = Some(new_value.to_string()); self } @@ -10320,7 +10316,7 @@ impl<'a, C, NC, A> TurnBasedMatcheLeaveTurnCall<'a, C, NC, A> where NC: hyper::n /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> TurnBasedMatcheLeaveTurnCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> TurnBasedMatcheLeaveTurnCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -10331,7 +10327,7 @@ impl<'a, C, NC, A> TurnBasedMatcheLeaveTurnCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheLeaveTurnCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheLeaveTurnCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10352,7 +10348,7 @@ impl<'a, C, NC, A> TurnBasedMatcheLeaveTurnCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheLeaveTurnCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheLeaveTurnCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10369,7 +10365,7 @@ impl<'a, C, NC, A> TurnBasedMatcheLeaveTurnCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheLeaveTurnCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheLeaveTurnCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10407,19 +10403,19 @@ impl<'a, C, NC, A> TurnBasedMatcheLeaveTurnCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct TurnBasedMatcheCancelCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TurnBasedMatcheCancelCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _match_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TurnBasedMatcheCancelCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TurnBasedMatcheCancelCall<'a, C, A> {} -impl<'a, C, NC, A> TurnBasedMatcheCancelCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TurnBasedMatcheCancelCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10540,7 +10536,7 @@ impl<'a, C, NC, A> TurnBasedMatcheCancelCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The ID of the match. - pub fn match_id(mut self, new_value: &str) -> TurnBasedMatcheCancelCall<'a, C, NC, A> { + pub fn match_id(mut self, new_value: &str) -> TurnBasedMatcheCancelCall<'a, C, A> { self._match_id = new_value.to_string(); self } @@ -10551,7 +10547,7 @@ impl<'a, C, NC, A> TurnBasedMatcheCancelCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheCancelCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheCancelCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10572,7 +10568,7 @@ impl<'a, C, NC, A> TurnBasedMatcheCancelCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheCancelCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheCancelCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10589,7 +10585,7 @@ impl<'a, C, NC, A> TurnBasedMatcheCancelCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheCancelCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheCancelCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10634,10 +10630,10 @@ impl<'a, C, NC, A> TurnBasedMatcheCancelCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct TurnBasedMatcheFinishCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TurnBasedMatcheFinishCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _request: TurnBasedMatchResults, _match_id: String, _language: Option, @@ -10646,9 +10642,9 @@ pub struct TurnBasedMatcheFinishCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TurnBasedMatcheFinishCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TurnBasedMatcheFinishCall<'a, C, A> {} -impl<'a, C, NC, A> TurnBasedMatcheFinishCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TurnBasedMatcheFinishCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10790,7 +10786,7 @@ impl<'a, C, NC, A> TurnBasedMatcheFinishCall<'a, C, NC, A> where NC: hyper::net: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &TurnBasedMatchResults) -> TurnBasedMatcheFinishCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &TurnBasedMatchResults) -> TurnBasedMatcheFinishCall<'a, C, A> { self._request = new_value.clone(); self } @@ -10800,7 +10796,7 @@ impl<'a, C, NC, A> TurnBasedMatcheFinishCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The ID of the match. - pub fn match_id(mut self, new_value: &str) -> TurnBasedMatcheFinishCall<'a, C, NC, A> { + pub fn match_id(mut self, new_value: &str) -> TurnBasedMatcheFinishCall<'a, C, A> { self._match_id = new_value.to_string(); self } @@ -10808,7 +10804,7 @@ impl<'a, C, NC, A> TurnBasedMatcheFinishCall<'a, C, NC, A> where NC: hyper::net: /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> TurnBasedMatcheFinishCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> TurnBasedMatcheFinishCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -10819,7 +10815,7 @@ impl<'a, C, NC, A> TurnBasedMatcheFinishCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheFinishCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheFinishCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10840,7 +10836,7 @@ impl<'a, C, NC, A> TurnBasedMatcheFinishCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheFinishCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheFinishCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10857,7 +10853,7 @@ impl<'a, C, NC, A> TurnBasedMatcheFinishCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheFinishCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheFinishCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10896,10 +10892,10 @@ impl<'a, C, NC, A> TurnBasedMatcheFinishCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct TurnBasedMatcheLeaveCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TurnBasedMatcheLeaveCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _match_id: String, _language: Option, _delegate: Option<&'a mut Delegate>, @@ -10907,9 +10903,9 @@ pub struct TurnBasedMatcheLeaveCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TurnBasedMatcheLeaveCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TurnBasedMatcheLeaveCall<'a, C, A> {} -impl<'a, C, NC, A> TurnBasedMatcheLeaveCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TurnBasedMatcheLeaveCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11044,7 +11040,7 @@ impl<'a, C, NC, A> TurnBasedMatcheLeaveCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The ID of the match. - pub fn match_id(mut self, new_value: &str) -> TurnBasedMatcheLeaveCall<'a, C, NC, A> { + pub fn match_id(mut self, new_value: &str) -> TurnBasedMatcheLeaveCall<'a, C, A> { self._match_id = new_value.to_string(); self } @@ -11052,7 +11048,7 @@ impl<'a, C, NC, A> TurnBasedMatcheLeaveCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> TurnBasedMatcheLeaveCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> TurnBasedMatcheLeaveCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -11063,7 +11059,7 @@ impl<'a, C, NC, A> TurnBasedMatcheLeaveCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheLeaveCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheLeaveCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11084,7 +11080,7 @@ impl<'a, C, NC, A> TurnBasedMatcheLeaveCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheLeaveCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheLeaveCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11101,7 +11097,7 @@ impl<'a, C, NC, A> TurnBasedMatcheLeaveCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheLeaveCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheLeaveCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11144,10 +11140,10 @@ impl<'a, C, NC, A> TurnBasedMatcheLeaveCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct TurnBasedMatcheListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TurnBasedMatcheListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _page_token: Option, _max_results: Option, _max_completed_matches: Option, @@ -11158,9 +11154,9 @@ pub struct TurnBasedMatcheListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TurnBasedMatcheListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TurnBasedMatcheListCall<'a, C, A> {} -impl<'a, C, NC, A> TurnBasedMatcheListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TurnBasedMatcheListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11280,7 +11276,7 @@ impl<'a, C, NC, A> TurnBasedMatcheListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> TurnBasedMatcheListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TurnBasedMatcheListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -11288,7 +11284,7 @@ impl<'a, C, NC, A> TurnBasedMatcheListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The maximum number of matches to return in the response, used for paging. For any response, the actual number of matches to return may be less than the specified maxResults. - pub fn max_results(mut self, new_value: i32) -> TurnBasedMatcheListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> TurnBasedMatcheListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -11296,7 +11292,7 @@ impl<'a, C, NC, A> TurnBasedMatcheListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The maximum number of completed or canceled matches to return in the response. If not set, all matches returned could be completed or canceled. - pub fn max_completed_matches(mut self, new_value: i32) -> TurnBasedMatcheListCall<'a, C, NC, A> { + pub fn max_completed_matches(mut self, new_value: i32) -> TurnBasedMatcheListCall<'a, C, A> { self._max_completed_matches = Some(new_value); self } @@ -11304,7 +11300,7 @@ impl<'a, C, NC, A> TurnBasedMatcheListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> TurnBasedMatcheListCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> TurnBasedMatcheListCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -11312,7 +11308,7 @@ impl<'a, C, NC, A> TurnBasedMatcheListCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// True if match data should be returned in the response. Note that not all data will necessarily be returned if include_match_data is true; the server may decide to only return data for some of the matches to limit download size for the client. The remainder of the data for these matches will be retrievable on request. - pub fn include_match_data(mut self, new_value: bool) -> TurnBasedMatcheListCall<'a, C, NC, A> { + pub fn include_match_data(mut self, new_value: bool) -> TurnBasedMatcheListCall<'a, C, A> { self._include_match_data = Some(new_value); self } @@ -11323,7 +11319,7 @@ impl<'a, C, NC, A> TurnBasedMatcheListCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11344,7 +11340,7 @@ impl<'a, C, NC, A> TurnBasedMatcheListCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11361,7 +11357,7 @@ impl<'a, C, NC, A> TurnBasedMatcheListCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11406,10 +11402,10 @@ impl<'a, C, NC, A> TurnBasedMatcheListCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct TurnBasedMatcheTakeTurnCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TurnBasedMatcheTakeTurnCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _request: TurnBasedMatchTurn, _match_id: String, _language: Option, @@ -11418,9 +11414,9 @@ pub struct TurnBasedMatcheTakeTurnCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TurnBasedMatcheTakeTurnCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TurnBasedMatcheTakeTurnCall<'a, C, A> {} -impl<'a, C, NC, A> TurnBasedMatcheTakeTurnCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TurnBasedMatcheTakeTurnCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11562,7 +11558,7 @@ impl<'a, C, NC, A> TurnBasedMatcheTakeTurnCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &TurnBasedMatchTurn) -> TurnBasedMatcheTakeTurnCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &TurnBasedMatchTurn) -> TurnBasedMatcheTakeTurnCall<'a, C, A> { self._request = new_value.clone(); self } @@ -11572,7 +11568,7 @@ impl<'a, C, NC, A> TurnBasedMatcheTakeTurnCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The ID of the match. - pub fn match_id(mut self, new_value: &str) -> TurnBasedMatcheTakeTurnCall<'a, C, NC, A> { + pub fn match_id(mut self, new_value: &str) -> TurnBasedMatcheTakeTurnCall<'a, C, A> { self._match_id = new_value.to_string(); self } @@ -11580,7 +11576,7 @@ impl<'a, C, NC, A> TurnBasedMatcheTakeTurnCall<'a, C, NC, A> where NC: hyper::ne /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> TurnBasedMatcheTakeTurnCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> TurnBasedMatcheTakeTurnCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -11591,7 +11587,7 @@ impl<'a, C, NC, A> TurnBasedMatcheTakeTurnCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheTakeTurnCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheTakeTurnCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11612,7 +11608,7 @@ impl<'a, C, NC, A> TurnBasedMatcheTakeTurnCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheTakeTurnCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheTakeTurnCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11629,7 +11625,7 @@ impl<'a, C, NC, A> TurnBasedMatcheTakeTurnCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheTakeTurnCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheTakeTurnCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11669,10 +11665,10 @@ impl<'a, C, NC, A> TurnBasedMatcheTakeTurnCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct TurnBasedMatcheRematchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TurnBasedMatcheRematchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _match_id: String, _request_id: Option, _language: Option, @@ -11681,9 +11677,9 @@ pub struct TurnBasedMatcheRematchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TurnBasedMatcheRematchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TurnBasedMatcheRematchCall<'a, C, A> {} -impl<'a, C, NC, A> TurnBasedMatcheRematchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TurnBasedMatcheRematchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11821,7 +11817,7 @@ impl<'a, C, NC, A> TurnBasedMatcheRematchCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The ID of the match. - pub fn match_id(mut self, new_value: &str) -> TurnBasedMatcheRematchCall<'a, C, NC, A> { + pub fn match_id(mut self, new_value: &str) -> TurnBasedMatcheRematchCall<'a, C, A> { self._match_id = new_value.to_string(); self } @@ -11829,7 +11825,7 @@ impl<'a, C, NC, A> TurnBasedMatcheRematchCall<'a, C, NC, A> where NC: hyper::net /// /// /// A randomly generated numeric ID for each request specified by the caller. This number is used at the server to ensure that the request is handled correctly across retries. - pub fn request_id(mut self, new_value: &str) -> TurnBasedMatcheRematchCall<'a, C, NC, A> { + pub fn request_id(mut self, new_value: &str) -> TurnBasedMatcheRematchCall<'a, C, A> { self._request_id = Some(new_value.to_string()); self } @@ -11837,7 +11833,7 @@ impl<'a, C, NC, A> TurnBasedMatcheRematchCall<'a, C, NC, A> where NC: hyper::net /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> TurnBasedMatcheRematchCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> TurnBasedMatcheRematchCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -11848,7 +11844,7 @@ impl<'a, C, NC, A> TurnBasedMatcheRematchCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheRematchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheRematchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11869,7 +11865,7 @@ impl<'a, C, NC, A> TurnBasedMatcheRematchCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheRematchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheRematchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11886,7 +11882,7 @@ impl<'a, C, NC, A> TurnBasedMatcheRematchCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheRematchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheRematchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11926,10 +11922,10 @@ impl<'a, C, NC, A> TurnBasedMatcheRematchCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct ApplicationGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ApplicationGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _application_id: String, _platform_type: Option, _language: Option, @@ -11938,9 +11934,9 @@ pub struct ApplicationGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ApplicationGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ApplicationGetCall<'a, C, A> {} -impl<'a, C, NC, A> ApplicationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ApplicationGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12078,7 +12074,7 @@ impl<'a, C, NC, A> ApplicationGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The application ID from the Google Play developer console. - pub fn application_id(mut self, new_value: &str) -> ApplicationGetCall<'a, C, NC, A> { + pub fn application_id(mut self, new_value: &str) -> ApplicationGetCall<'a, C, A> { self._application_id = new_value.to_string(); self } @@ -12086,7 +12082,7 @@ impl<'a, C, NC, A> ApplicationGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Restrict application details returned to the specific platform. - pub fn platform_type(mut self, new_value: &str) -> ApplicationGetCall<'a, C, NC, A> { + pub fn platform_type(mut self, new_value: &str) -> ApplicationGetCall<'a, C, A> { self._platform_type = Some(new_value.to_string()); self } @@ -12094,7 +12090,7 @@ impl<'a, C, NC, A> ApplicationGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> ApplicationGetCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> ApplicationGetCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -12105,7 +12101,7 @@ impl<'a, C, NC, A> ApplicationGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ApplicationGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ApplicationGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12126,7 +12122,7 @@ impl<'a, C, NC, A> ApplicationGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ApplicationGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ApplicationGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12143,7 +12139,7 @@ impl<'a, C, NC, A> ApplicationGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ApplicationGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ApplicationGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12181,18 +12177,18 @@ impl<'a, C, NC, A> ApplicationGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct ApplicationPlayedCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ApplicationPlayedCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ApplicationPlayedCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ApplicationPlayedCall<'a, C, A> {} -impl<'a, C, NC, A> ApplicationPlayedCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ApplicationPlayedCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12289,7 +12285,7 @@ impl<'a, C, NC, A> ApplicationPlayedCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ApplicationPlayedCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ApplicationPlayedCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12310,7 +12306,7 @@ impl<'a, C, NC, A> ApplicationPlayedCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ApplicationPlayedCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ApplicationPlayedCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12327,7 +12323,7 @@ impl<'a, C, NC, A> ApplicationPlayedCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ApplicationPlayedCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ApplicationPlayedCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12366,10 +12362,10 @@ impl<'a, C, NC, A> ApplicationPlayedCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct RoomGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RoomGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _room_id: String, _language: Option, _delegate: Option<&'a mut Delegate>, @@ -12377,9 +12373,9 @@ pub struct RoomGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RoomGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RoomGetCall<'a, C, A> {} -impl<'a, C, NC, A> RoomGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RoomGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12514,7 +12510,7 @@ impl<'a, C, NC, A> RoomGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// The ID of the room. - pub fn room_id(mut self, new_value: &str) -> RoomGetCall<'a, C, NC, A> { + pub fn room_id(mut self, new_value: &str) -> RoomGetCall<'a, C, A> { self._room_id = new_value.to_string(); self } @@ -12522,7 +12518,7 @@ impl<'a, C, NC, A> RoomGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> RoomGetCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> RoomGetCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -12533,7 +12529,7 @@ impl<'a, C, NC, A> RoomGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RoomGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RoomGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12554,7 +12550,7 @@ impl<'a, C, NC, A> RoomGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RoomGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RoomGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12571,7 +12567,7 @@ impl<'a, C, NC, A> RoomGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RoomGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RoomGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12616,10 +12612,10 @@ impl<'a, C, NC, A> RoomGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct RoomLeaveCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RoomLeaveCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _request: RoomLeaveRequest, _room_id: String, _language: Option, @@ -12628,9 +12624,9 @@ pub struct RoomLeaveCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RoomLeaveCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RoomLeaveCall<'a, C, A> {} -impl<'a, C, NC, A> RoomLeaveCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RoomLeaveCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12772,7 +12768,7 @@ impl<'a, C, NC, A> RoomLeaveCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &RoomLeaveRequest) -> RoomLeaveCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &RoomLeaveRequest) -> RoomLeaveCall<'a, C, A> { self._request = new_value.clone(); self } @@ -12782,7 +12778,7 @@ impl<'a, C, NC, A> RoomLeaveCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the room. - pub fn room_id(mut self, new_value: &str) -> RoomLeaveCall<'a, C, NC, A> { + pub fn room_id(mut self, new_value: &str) -> RoomLeaveCall<'a, C, A> { self._room_id = new_value.to_string(); self } @@ -12790,7 +12786,7 @@ impl<'a, C, NC, A> RoomLeaveCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> RoomLeaveCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> RoomLeaveCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -12801,7 +12797,7 @@ impl<'a, C, NC, A> RoomLeaveCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RoomLeaveCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RoomLeaveCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12822,7 +12818,7 @@ impl<'a, C, NC, A> RoomLeaveCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RoomLeaveCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RoomLeaveCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12839,7 +12835,7 @@ impl<'a, C, NC, A> RoomLeaveCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RoomLeaveCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RoomLeaveCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12880,10 +12876,10 @@ impl<'a, C, NC, A> RoomLeaveCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct RoomListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RoomListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _page_token: Option, _max_results: Option, _language: Option, @@ -12892,9 +12888,9 @@ pub struct RoomListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RoomListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RoomListCall<'a, C, A> {} -impl<'a, C, NC, A> RoomListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RoomListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13008,7 +13004,7 @@ impl<'a, C, NC, A> RoomListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> RoomListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> RoomListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -13016,7 +13012,7 @@ impl<'a, C, NC, A> RoomListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The maximum number of rooms to return in the response, used for paging. For any response, the actual number of rooms to return may be less than the specified maxResults. - pub fn max_results(mut self, new_value: i32) -> RoomListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> RoomListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -13024,7 +13020,7 @@ impl<'a, C, NC, A> RoomListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> RoomListCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> RoomListCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -13035,7 +13031,7 @@ impl<'a, C, NC, A> RoomListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RoomListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RoomListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13056,7 +13052,7 @@ impl<'a, C, NC, A> RoomListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RoomListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RoomListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13073,7 +13069,7 @@ impl<'a, C, NC, A> RoomListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RoomListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RoomListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13118,10 +13114,10 @@ impl<'a, C, NC, A> RoomListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct RoomReportStatuCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RoomReportStatuCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _request: RoomP2PStatuses, _room_id: String, _language: Option, @@ -13130,9 +13126,9 @@ pub struct RoomReportStatuCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RoomReportStatuCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RoomReportStatuCall<'a, C, A> {} -impl<'a, C, NC, A> RoomReportStatuCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RoomReportStatuCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13274,7 +13270,7 @@ impl<'a, C, NC, A> RoomReportStatuCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &RoomP2PStatuses) -> RoomReportStatuCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &RoomP2PStatuses) -> RoomReportStatuCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13284,7 +13280,7 @@ impl<'a, C, NC, A> RoomReportStatuCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the room. - pub fn room_id(mut self, new_value: &str) -> RoomReportStatuCall<'a, C, NC, A> { + pub fn room_id(mut self, new_value: &str) -> RoomReportStatuCall<'a, C, A> { self._room_id = new_value.to_string(); self } @@ -13292,7 +13288,7 @@ impl<'a, C, NC, A> RoomReportStatuCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> RoomReportStatuCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> RoomReportStatuCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -13303,7 +13299,7 @@ impl<'a, C, NC, A> RoomReportStatuCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RoomReportStatuCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RoomReportStatuCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13324,7 +13320,7 @@ impl<'a, C, NC, A> RoomReportStatuCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RoomReportStatuCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RoomReportStatuCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13341,7 +13337,7 @@ impl<'a, C, NC, A> RoomReportStatuCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RoomReportStatuCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RoomReportStatuCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13386,10 +13382,10 @@ impl<'a, C, NC, A> RoomReportStatuCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct RoomCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RoomCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _request: RoomCreateRequest, _language: Option, _delegate: Option<&'a mut Delegate>, @@ -13397,9 +13393,9 @@ pub struct RoomCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RoomCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RoomCreateCall<'a, C, A> {} -impl<'a, C, NC, A> RoomCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RoomCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13516,7 +13512,7 @@ impl<'a, C, NC, A> RoomCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &RoomCreateRequest) -> RoomCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &RoomCreateRequest) -> RoomCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13524,7 +13520,7 @@ impl<'a, C, NC, A> RoomCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> RoomCreateCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> RoomCreateCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -13535,7 +13531,7 @@ impl<'a, C, NC, A> RoomCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RoomCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RoomCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13556,7 +13552,7 @@ impl<'a, C, NC, A> RoomCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RoomCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RoomCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13573,7 +13569,7 @@ impl<'a, C, NC, A> RoomCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RoomCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RoomCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13612,10 +13608,10 @@ impl<'a, C, NC, A> RoomCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct RoomDeclineCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RoomDeclineCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _room_id: String, _language: Option, _delegate: Option<&'a mut Delegate>, @@ -13623,9 +13619,9 @@ pub struct RoomDeclineCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RoomDeclineCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RoomDeclineCall<'a, C, A> {} -impl<'a, C, NC, A> RoomDeclineCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RoomDeclineCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13760,7 +13756,7 @@ impl<'a, C, NC, A> RoomDeclineCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the room. - pub fn room_id(mut self, new_value: &str) -> RoomDeclineCall<'a, C, NC, A> { + pub fn room_id(mut self, new_value: &str) -> RoomDeclineCall<'a, C, A> { self._room_id = new_value.to_string(); self } @@ -13768,7 +13764,7 @@ impl<'a, C, NC, A> RoomDeclineCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> RoomDeclineCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> RoomDeclineCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -13779,7 +13775,7 @@ impl<'a, C, NC, A> RoomDeclineCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RoomDeclineCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RoomDeclineCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13800,7 +13796,7 @@ impl<'a, C, NC, A> RoomDeclineCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RoomDeclineCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RoomDeclineCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13817,7 +13813,7 @@ impl<'a, C, NC, A> RoomDeclineCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RoomDeclineCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RoomDeclineCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13855,19 +13851,19 @@ impl<'a, C, NC, A> RoomDeclineCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct RoomDismisCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RoomDismisCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _room_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RoomDismisCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RoomDismisCall<'a, C, A> {} -impl<'a, C, NC, A> RoomDismisCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RoomDismisCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13988,7 +13984,7 @@ impl<'a, C, NC, A> RoomDismisCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the room. - pub fn room_id(mut self, new_value: &str) -> RoomDismisCall<'a, C, NC, A> { + pub fn room_id(mut self, new_value: &str) -> RoomDismisCall<'a, C, A> { self._room_id = new_value.to_string(); self } @@ -13999,7 +13995,7 @@ impl<'a, C, NC, A> RoomDismisCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RoomDismisCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RoomDismisCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14020,7 +14016,7 @@ impl<'a, C, NC, A> RoomDismisCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RoomDismisCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RoomDismisCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14037,7 +14033,7 @@ impl<'a, C, NC, A> RoomDismisCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RoomDismisCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RoomDismisCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14082,10 +14078,10 @@ impl<'a, C, NC, A> RoomDismisCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct RoomJoinCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RoomJoinCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _request: RoomJoinRequest, _room_id: String, _language: Option, @@ -14094,9 +14090,9 @@ pub struct RoomJoinCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RoomJoinCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RoomJoinCall<'a, C, A> {} -impl<'a, C, NC, A> RoomJoinCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RoomJoinCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14238,7 +14234,7 @@ impl<'a, C, NC, A> RoomJoinCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &RoomJoinRequest) -> RoomJoinCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &RoomJoinRequest) -> RoomJoinCall<'a, C, A> { self._request = new_value.clone(); self } @@ -14248,7 +14244,7 @@ impl<'a, C, NC, A> RoomJoinCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The ID of the room. - pub fn room_id(mut self, new_value: &str) -> RoomJoinCall<'a, C, NC, A> { + pub fn room_id(mut self, new_value: &str) -> RoomJoinCall<'a, C, A> { self._room_id = new_value.to_string(); self } @@ -14256,7 +14252,7 @@ impl<'a, C, NC, A> RoomJoinCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> RoomJoinCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> RoomJoinCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -14267,7 +14263,7 @@ impl<'a, C, NC, A> RoomJoinCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RoomJoinCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RoomJoinCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14288,7 +14284,7 @@ impl<'a, C, NC, A> RoomJoinCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RoomJoinCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RoomJoinCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14305,7 +14301,7 @@ impl<'a, C, NC, A> RoomJoinCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RoomJoinCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RoomJoinCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14345,10 +14341,10 @@ impl<'a, C, NC, A> RoomJoinCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct ScoreSubmitCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ScoreSubmitCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _leaderboard_id: String, _score: String, _score_tag: Option, @@ -14358,9 +14354,9 @@ pub struct ScoreSubmitCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ScoreSubmitCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ScoreSubmitCall<'a, C, A> {} -impl<'a, C, NC, A> ScoreSubmitCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ScoreSubmitCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14499,7 +14495,7 @@ impl<'a, C, NC, A> ScoreSubmitCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the leaderboard. - pub fn leaderboard_id(mut self, new_value: &str) -> ScoreSubmitCall<'a, C, NC, A> { + pub fn leaderboard_id(mut self, new_value: &str) -> ScoreSubmitCall<'a, C, A> { self._leaderboard_id = new_value.to_string(); self } @@ -14509,7 +14505,7 @@ impl<'a, C, NC, A> ScoreSubmitCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The score you're submitting. The submitted score is ignored if it is worse than a previously submitted score, where worse depends on the leaderboard sort order. The meaning of the score value depends on the leaderboard format type. For fixed-point, the score represents the raw value. For time, the score represents elapsed time in milliseconds. For currency, the score represents a value in micro units. - pub fn score(mut self, new_value: &str) -> ScoreSubmitCall<'a, C, NC, A> { + pub fn score(mut self, new_value: &str) -> ScoreSubmitCall<'a, C, A> { self._score = new_value.to_string(); self } @@ -14517,7 +14513,7 @@ impl<'a, C, NC, A> ScoreSubmitCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Additional information about the score you're submitting. Values must contain no more than 64 URI-safe characters as defined by section 2.3 of RFC 3986. - pub fn score_tag(mut self, new_value: &str) -> ScoreSubmitCall<'a, C, NC, A> { + pub fn score_tag(mut self, new_value: &str) -> ScoreSubmitCall<'a, C, A> { self._score_tag = Some(new_value.to_string()); self } @@ -14525,7 +14521,7 @@ impl<'a, C, NC, A> ScoreSubmitCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> ScoreSubmitCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> ScoreSubmitCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -14536,7 +14532,7 @@ impl<'a, C, NC, A> ScoreSubmitCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScoreSubmitCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScoreSubmitCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14557,7 +14553,7 @@ impl<'a, C, NC, A> ScoreSubmitCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ScoreSubmitCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ScoreSubmitCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14574,7 +14570,7 @@ impl<'a, C, NC, A> ScoreSubmitCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ScoreSubmitCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ScoreSubmitCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14615,10 +14611,10 @@ impl<'a, C, NC, A> ScoreSubmitCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct ScoreListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ScoreListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _leaderboard_id: String, _collection: String, _time_span: String, @@ -14630,9 +14626,9 @@ pub struct ScoreListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ScoreListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ScoreListCall<'a, C, A> {} -impl<'a, C, NC, A> ScoreListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ScoreListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14775,7 +14771,7 @@ impl<'a, C, NC, A> ScoreListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the leaderboard. - pub fn leaderboard_id(mut self, new_value: &str) -> ScoreListCall<'a, C, NC, A> { + pub fn leaderboard_id(mut self, new_value: &str) -> ScoreListCall<'a, C, A> { self._leaderboard_id = new_value.to_string(); self } @@ -14785,7 +14781,7 @@ impl<'a, C, NC, A> ScoreListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The collection of scores you're requesting. - pub fn collection(mut self, new_value: &str) -> ScoreListCall<'a, C, NC, A> { + pub fn collection(mut self, new_value: &str) -> ScoreListCall<'a, C, A> { self._collection = new_value.to_string(); self } @@ -14795,7 +14791,7 @@ impl<'a, C, NC, A> ScoreListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The time span for the scores and ranks you're requesting. - pub fn time_span(mut self, new_value: &str) -> ScoreListCall<'a, C, NC, A> { + pub fn time_span(mut self, new_value: &str) -> ScoreListCall<'a, C, A> { self._time_span = new_value.to_string(); self } @@ -14803,7 +14799,7 @@ impl<'a, C, NC, A> ScoreListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> ScoreListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ScoreListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -14811,7 +14807,7 @@ impl<'a, C, NC, A> ScoreListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The maximum number of leaderboard scores to return in the response. For any response, the actual number of leaderboard scores returned may be less than the specified maxResults. - pub fn max_results(mut self, new_value: i32) -> ScoreListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ScoreListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -14819,7 +14815,7 @@ impl<'a, C, NC, A> ScoreListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> ScoreListCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> ScoreListCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -14830,7 +14826,7 @@ impl<'a, C, NC, A> ScoreListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScoreListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScoreListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14851,7 +14847,7 @@ impl<'a, C, NC, A> ScoreListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ScoreListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ScoreListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14868,7 +14864,7 @@ impl<'a, C, NC, A> ScoreListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ScoreListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ScoreListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14911,10 +14907,10 @@ impl<'a, C, NC, A> ScoreListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct ScoreGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ScoreGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _player_id: String, _leaderboard_id: String, _time_span: String, @@ -14927,9 +14923,9 @@ pub struct ScoreGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ScoreGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ScoreGetCall<'a, C, A> {} -impl<'a, C, NC, A> ScoreGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ScoreGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15075,7 +15071,7 @@ impl<'a, C, NC, A> ScoreGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// A player ID. A value of me may be used in place of the authenticated player's ID. - pub fn player_id(mut self, new_value: &str) -> ScoreGetCall<'a, C, NC, A> { + pub fn player_id(mut self, new_value: &str) -> ScoreGetCall<'a, C, A> { self._player_id = new_value.to_string(); self } @@ -15085,7 +15081,7 @@ impl<'a, C, NC, A> ScoreGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The ID of the leaderboard. Can be set to 'ALL' to retrieve data for all leaderboards for this application. - pub fn leaderboard_id(mut self, new_value: &str) -> ScoreGetCall<'a, C, NC, A> { + pub fn leaderboard_id(mut self, new_value: &str) -> ScoreGetCall<'a, C, A> { self._leaderboard_id = new_value.to_string(); self } @@ -15095,7 +15091,7 @@ impl<'a, C, NC, A> ScoreGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The time span for the scores and ranks you're requesting. - pub fn time_span(mut self, new_value: &str) -> ScoreGetCall<'a, C, NC, A> { + pub fn time_span(mut self, new_value: &str) -> ScoreGetCall<'a, C, A> { self._time_span = new_value.to_string(); self } @@ -15103,7 +15099,7 @@ impl<'a, C, NC, A> ScoreGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> ScoreGetCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ScoreGetCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -15111,7 +15107,7 @@ impl<'a, C, NC, A> ScoreGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The maximum number of leaderboard scores to return in the response. For any response, the actual number of leaderboard scores returned may be less than the specified maxResults. - pub fn max_results(mut self, new_value: i32) -> ScoreGetCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ScoreGetCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -15119,7 +15115,7 @@ impl<'a, C, NC, A> ScoreGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> ScoreGetCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> ScoreGetCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -15127,7 +15123,7 @@ impl<'a, C, NC, A> ScoreGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The types of ranks to return. If the parameter is omitted, no ranks will be returned. - pub fn include_rank_type(mut self, new_value: &str) -> ScoreGetCall<'a, C, NC, A> { + pub fn include_rank_type(mut self, new_value: &str) -> ScoreGetCall<'a, C, A> { self._include_rank_type = Some(new_value.to_string()); self } @@ -15138,7 +15134,7 @@ impl<'a, C, NC, A> ScoreGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScoreGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScoreGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15159,7 +15155,7 @@ impl<'a, C, NC, A> ScoreGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ScoreGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ScoreGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15176,7 +15172,7 @@ impl<'a, C, NC, A> ScoreGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ScoreGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ScoreGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15221,10 +15217,10 @@ impl<'a, C, NC, A> ScoreGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct ScoreSubmitMultipleCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ScoreSubmitMultipleCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _request: PlayerScoreSubmissionList, _language: Option, _delegate: Option<&'a mut Delegate>, @@ -15232,9 +15228,9 @@ pub struct ScoreSubmitMultipleCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ScoreSubmitMultipleCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ScoreSubmitMultipleCall<'a, C, A> {} -impl<'a, C, NC, A> ScoreSubmitMultipleCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ScoreSubmitMultipleCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15351,7 +15347,7 @@ impl<'a, C, NC, A> ScoreSubmitMultipleCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PlayerScoreSubmissionList) -> ScoreSubmitMultipleCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PlayerScoreSubmissionList) -> ScoreSubmitMultipleCall<'a, C, A> { self._request = new_value.clone(); self } @@ -15359,7 +15355,7 @@ impl<'a, C, NC, A> ScoreSubmitMultipleCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> ScoreSubmitMultipleCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> ScoreSubmitMultipleCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -15370,7 +15366,7 @@ impl<'a, C, NC, A> ScoreSubmitMultipleCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScoreSubmitMultipleCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScoreSubmitMultipleCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15391,7 +15387,7 @@ impl<'a, C, NC, A> ScoreSubmitMultipleCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ScoreSubmitMultipleCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ScoreSubmitMultipleCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15408,7 +15404,7 @@ impl<'a, C, NC, A> ScoreSubmitMultipleCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ScoreSubmitMultipleCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ScoreSubmitMultipleCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15451,10 +15447,10 @@ impl<'a, C, NC, A> ScoreSubmitMultipleCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct ScoreListWindowCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ScoreListWindowCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _leaderboard_id: String, _collection: String, _time_span: String, @@ -15468,9 +15464,9 @@ pub struct ScoreListWindowCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ScoreListWindowCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ScoreListWindowCall<'a, C, A> {} -impl<'a, C, NC, A> ScoreListWindowCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ScoreListWindowCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15619,7 +15615,7 @@ impl<'a, C, NC, A> ScoreListWindowCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the leaderboard. - pub fn leaderboard_id(mut self, new_value: &str) -> ScoreListWindowCall<'a, C, NC, A> { + pub fn leaderboard_id(mut self, new_value: &str) -> ScoreListWindowCall<'a, C, A> { self._leaderboard_id = new_value.to_string(); self } @@ -15629,7 +15625,7 @@ impl<'a, C, NC, A> ScoreListWindowCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The collection of scores you're requesting. - pub fn collection(mut self, new_value: &str) -> ScoreListWindowCall<'a, C, NC, A> { + pub fn collection(mut self, new_value: &str) -> ScoreListWindowCall<'a, C, A> { self._collection = new_value.to_string(); self } @@ -15639,7 +15635,7 @@ impl<'a, C, NC, A> ScoreListWindowCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The time span for the scores and ranks you're requesting. - pub fn time_span(mut self, new_value: &str) -> ScoreListWindowCall<'a, C, NC, A> { + pub fn time_span(mut self, new_value: &str) -> ScoreListWindowCall<'a, C, A> { self._time_span = new_value.to_string(); self } @@ -15647,7 +15643,7 @@ impl<'a, C, NC, A> ScoreListWindowCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// True if the top scores should be returned when the player is not in the leaderboard. Defaults to true. - pub fn return_top_if_absent(mut self, new_value: bool) -> ScoreListWindowCall<'a, C, NC, A> { + pub fn return_top_if_absent(mut self, new_value: bool) -> ScoreListWindowCall<'a, C, A> { self._return_top_if_absent = Some(new_value); self } @@ -15655,7 +15651,7 @@ impl<'a, C, NC, A> ScoreListWindowCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The preferred number of scores to return above the player's score. More scores may be returned if the player is at the bottom of the leaderboard; fewer may be returned if the player is at the top. Must be less than or equal to maxResults. - pub fn results_above(mut self, new_value: i32) -> ScoreListWindowCall<'a, C, NC, A> { + pub fn results_above(mut self, new_value: i32) -> ScoreListWindowCall<'a, C, A> { self._results_above = Some(new_value); self } @@ -15663,7 +15659,7 @@ impl<'a, C, NC, A> ScoreListWindowCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> ScoreListWindowCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ScoreListWindowCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -15671,7 +15667,7 @@ impl<'a, C, NC, A> ScoreListWindowCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The maximum number of leaderboard scores to return in the response. For any response, the actual number of leaderboard scores returned may be less than the specified maxResults. - pub fn max_results(mut self, new_value: i32) -> ScoreListWindowCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ScoreListWindowCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -15679,7 +15675,7 @@ impl<'a, C, NC, A> ScoreListWindowCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> ScoreListWindowCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> ScoreListWindowCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -15690,7 +15686,7 @@ impl<'a, C, NC, A> ScoreListWindowCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScoreListWindowCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScoreListWindowCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15711,7 +15707,7 @@ impl<'a, C, NC, A> ScoreListWindowCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ScoreListWindowCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ScoreListWindowCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15728,7 +15724,7 @@ impl<'a, C, NC, A> ScoreListWindowCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ScoreListWindowCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ScoreListWindowCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15772,19 +15768,19 @@ impl<'a, C, NC, A> ScoreListWindowCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct PushtokenRemoveCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PushtokenRemoveCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _request: PushTokenId, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PushtokenRemoveCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PushtokenRemoveCall<'a, C, A> {} -impl<'a, C, NC, A> PushtokenRemoveCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PushtokenRemoveCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15887,7 +15883,7 @@ impl<'a, C, NC, A> PushtokenRemoveCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PushTokenId) -> PushtokenRemoveCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PushTokenId) -> PushtokenRemoveCall<'a, C, A> { self._request = new_value.clone(); self } @@ -15898,7 +15894,7 @@ impl<'a, C, NC, A> PushtokenRemoveCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PushtokenRemoveCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PushtokenRemoveCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15919,7 +15915,7 @@ impl<'a, C, NC, A> PushtokenRemoveCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PushtokenRemoveCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PushtokenRemoveCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15936,7 +15932,7 @@ impl<'a, C, NC, A> PushtokenRemoveCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PushtokenRemoveCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PushtokenRemoveCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15980,19 +15976,19 @@ impl<'a, C, NC, A> PushtokenRemoveCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct PushtokenUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PushtokenUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _request: PushToken, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PushtokenUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PushtokenUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> PushtokenUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PushtokenUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16095,7 +16091,7 @@ impl<'a, C, NC, A> PushtokenUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PushToken) -> PushtokenUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PushToken) -> PushtokenUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -16106,7 +16102,7 @@ impl<'a, C, NC, A> PushtokenUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PushtokenUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PushtokenUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16127,7 +16123,7 @@ impl<'a, C, NC, A> PushtokenUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PushtokenUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PushtokenUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16144,7 +16140,7 @@ impl<'a, C, NC, A> PushtokenUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PushtokenUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PushtokenUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16182,19 +16178,19 @@ impl<'a, C, NC, A> PushtokenUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct RevisionCheckCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RevisionCheckCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _client_revision: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RevisionCheckCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RevisionCheckCall<'a, C, A> {} -impl<'a, C, NC, A> RevisionCheckCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RevisionCheckCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16307,7 +16303,7 @@ impl<'a, C, NC, A> RevisionCheckCall<'a, C, NC, A> where NC: hyper::net::Network /// - "ANDROID" - Client is running the Android SDK. /// - "IOS" - Client is running the iOS SDK. /// - "WEB_APP" - Client is running as a Web App. - pub fn client_revision(mut self, new_value: &str) -> RevisionCheckCall<'a, C, NC, A> { + pub fn client_revision(mut self, new_value: &str) -> RevisionCheckCall<'a, C, A> { self._client_revision = new_value.to_string(); self } @@ -16318,7 +16314,7 @@ impl<'a, C, NC, A> RevisionCheckCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RevisionCheckCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RevisionCheckCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16339,7 +16335,7 @@ impl<'a, C, NC, A> RevisionCheckCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RevisionCheckCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RevisionCheckCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16356,7 +16352,7 @@ impl<'a, C, NC, A> RevisionCheckCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RevisionCheckCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RevisionCheckCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16397,10 +16393,10 @@ impl<'a, C, NC, A> RevisionCheckCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct EventListDefinitionCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventListDefinitionCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _page_token: Option, _max_results: Option, _language: Option, @@ -16409,9 +16405,9 @@ pub struct EventListDefinitionCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventListDefinitionCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventListDefinitionCall<'a, C, A> {} -impl<'a, C, NC, A> EventListDefinitionCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventListDefinitionCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16525,7 +16521,7 @@ impl<'a, C, NC, A> EventListDefinitionCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> EventListDefinitionCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> EventListDefinitionCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -16533,7 +16529,7 @@ impl<'a, C, NC, A> EventListDefinitionCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The maximum number of event definitions to return in the response, used for paging. For any response, the actual number of event definitions to return may be less than the specified maxResults. - pub fn max_results(mut self, new_value: i32) -> EventListDefinitionCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> EventListDefinitionCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -16541,7 +16537,7 @@ impl<'a, C, NC, A> EventListDefinitionCall<'a, C, NC, A> where NC: hyper::net::N /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> EventListDefinitionCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> EventListDefinitionCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -16552,7 +16548,7 @@ impl<'a, C, NC, A> EventListDefinitionCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventListDefinitionCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventListDefinitionCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16573,7 +16569,7 @@ impl<'a, C, NC, A> EventListDefinitionCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventListDefinitionCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventListDefinitionCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16590,7 +16586,7 @@ impl<'a, C, NC, A> EventListDefinitionCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventListDefinitionCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventListDefinitionCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16635,10 +16631,10 @@ impl<'a, C, NC, A> EventListDefinitionCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct EventRecordCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventRecordCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _request: EventRecordRequest, _language: Option, _delegate: Option<&'a mut Delegate>, @@ -16646,9 +16642,9 @@ pub struct EventRecordCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventRecordCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventRecordCall<'a, C, A> {} -impl<'a, C, NC, A> EventRecordCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventRecordCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16765,7 +16761,7 @@ impl<'a, C, NC, A> EventRecordCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &EventRecordRequest) -> EventRecordCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &EventRecordRequest) -> EventRecordCall<'a, C, A> { self._request = new_value.clone(); self } @@ -16773,7 +16769,7 @@ impl<'a, C, NC, A> EventRecordCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> EventRecordCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> EventRecordCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -16784,7 +16780,7 @@ impl<'a, C, NC, A> EventRecordCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventRecordCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventRecordCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16805,7 +16801,7 @@ impl<'a, C, NC, A> EventRecordCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventRecordCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventRecordCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16822,7 +16818,7 @@ impl<'a, C, NC, A> EventRecordCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventRecordCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventRecordCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16863,10 +16859,10 @@ impl<'a, C, NC, A> EventRecordCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct EventListByPlayerCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventListByPlayerCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _page_token: Option, _max_results: Option, _language: Option, @@ -16875,9 +16871,9 @@ pub struct EventListByPlayerCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventListByPlayerCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventListByPlayerCall<'a, C, A> {} -impl<'a, C, NC, A> EventListByPlayerCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventListByPlayerCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16991,7 +16987,7 @@ impl<'a, C, NC, A> EventListByPlayerCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> EventListByPlayerCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> EventListByPlayerCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -16999,7 +16995,7 @@ impl<'a, C, NC, A> EventListByPlayerCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The maximum number of events to return in the response, used for paging. For any response, the actual number of events to return may be less than the specified maxResults. - pub fn max_results(mut self, new_value: i32) -> EventListByPlayerCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> EventListByPlayerCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -17007,7 +17003,7 @@ impl<'a, C, NC, A> EventListByPlayerCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> EventListByPlayerCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> EventListByPlayerCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -17018,7 +17014,7 @@ impl<'a, C, NC, A> EventListByPlayerCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventListByPlayerCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventListByPlayerCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17039,7 +17035,7 @@ impl<'a, C, NC, A> EventListByPlayerCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventListByPlayerCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventListByPlayerCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17056,7 +17052,7 @@ impl<'a, C, NC, A> EventListByPlayerCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventListByPlayerCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventListByPlayerCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17094,10 +17090,10 @@ impl<'a, C, NC, A> EventListByPlayerCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct QuestMilestoneClaimCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct QuestMilestoneClaimCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _quest_id: String, _milestone_id: String, _request_id: String, @@ -17106,9 +17102,9 @@ pub struct QuestMilestoneClaimCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for QuestMilestoneClaimCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for QuestMilestoneClaimCall<'a, C, A> {} -impl<'a, C, NC, A> QuestMilestoneClaimCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> QuestMilestoneClaimCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17231,7 +17227,7 @@ impl<'a, C, NC, A> QuestMilestoneClaimCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The ID of the quest. - pub fn quest_id(mut self, new_value: &str) -> QuestMilestoneClaimCall<'a, C, NC, A> { + pub fn quest_id(mut self, new_value: &str) -> QuestMilestoneClaimCall<'a, C, A> { self._quest_id = new_value.to_string(); self } @@ -17241,7 +17237,7 @@ impl<'a, C, NC, A> QuestMilestoneClaimCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The ID of the milestone. - pub fn milestone_id(mut self, new_value: &str) -> QuestMilestoneClaimCall<'a, C, NC, A> { + pub fn milestone_id(mut self, new_value: &str) -> QuestMilestoneClaimCall<'a, C, A> { self._milestone_id = new_value.to_string(); self } @@ -17251,7 +17247,7 @@ impl<'a, C, NC, A> QuestMilestoneClaimCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// A numeric ID to ensure that the request is handled correctly across retries. Your client application must generate this ID randomly. - pub fn request_id(mut self, new_value: &str) -> QuestMilestoneClaimCall<'a, C, NC, A> { + pub fn request_id(mut self, new_value: &str) -> QuestMilestoneClaimCall<'a, C, A> { self._request_id = new_value.to_string(); self } @@ -17262,7 +17258,7 @@ impl<'a, C, NC, A> QuestMilestoneClaimCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> QuestMilestoneClaimCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> QuestMilestoneClaimCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17283,7 +17279,7 @@ impl<'a, C, NC, A> QuestMilestoneClaimCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> QuestMilestoneClaimCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> QuestMilestoneClaimCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17300,7 +17296,7 @@ impl<'a, C, NC, A> QuestMilestoneClaimCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> QuestMilestoneClaimCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> QuestMilestoneClaimCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17341,10 +17337,10 @@ impl<'a, C, NC, A> QuestMilestoneClaimCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct AchievementDefinitionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AchievementDefinitionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Games, + hub: &'a Games, _page_token: Option, _max_results: Option, _language: Option, @@ -17353,9 +17349,9 @@ pub struct AchievementDefinitionListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AchievementDefinitionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AchievementDefinitionListCall<'a, C, A> {} -impl<'a, C, NC, A> AchievementDefinitionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AchievementDefinitionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17469,7 +17465,7 @@ impl<'a, C, NC, A> AchievementDefinitionListCall<'a, C, NC, A> where NC: hyper:: /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> AchievementDefinitionListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AchievementDefinitionListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -17477,7 +17473,7 @@ impl<'a, C, NC, A> AchievementDefinitionListCall<'a, C, NC, A> where NC: hyper:: /// /// /// The maximum number of achievement resources to return in the response, used for paging. For any response, the actual number of achievement resources returned may be less than the specified maxResults. - pub fn max_results(mut self, new_value: i32) -> AchievementDefinitionListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AchievementDefinitionListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -17485,7 +17481,7 @@ impl<'a, C, NC, A> AchievementDefinitionListCall<'a, C, NC, A> where NC: hyper:: /// /// /// The preferred language to use for strings returned by this method. - pub fn language(mut self, new_value: &str) -> AchievementDefinitionListCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> AchievementDefinitionListCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -17496,7 +17492,7 @@ impl<'a, C, NC, A> AchievementDefinitionListCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementDefinitionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementDefinitionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17517,7 +17513,7 @@ impl<'a, C, NC, A> AchievementDefinitionListCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AchievementDefinitionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AchievementDefinitionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17534,7 +17530,7 @@ impl<'a, C, NC, A> AchievementDefinitionListCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AchievementDefinitionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AchievementDefinitionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/gamesconfiguration1_configuration/Cargo.toml b/gen/gamesconfiguration1_configuration/Cargo.toml index f31041f08e7..7c10971a4a0 100644 --- a/gen/gamesconfiguration1_configuration/Cargo.toml +++ b/gen/gamesconfiguration1_configuration/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-gamesconfiguration1_configuration" -version = "0.1.4+20150325" +version = "0.1.5+20150325" authors = ["Sebastian Thiel "] description = "A complete library to interact with Games Configuration (protocol v1configuration)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/gamesconfiguration1_configuration" homepage = "https://developers.google.com/games/services" -documentation = "http://byron.github.io/google-apis-rs/google-gamesconfiguration1_configuration" +documentation = "http://byron.github.io/google-apis-rs/google_gamesconfiguration1_configuration" license = "MIT" keywords = ["gamesConfiguration", "google", "protocol", "web", "api"] diff --git a/gen/gamesconfiguration1_configuration/README.md b/gen/gamesconfiguration1_configuration/README.md index 243b5edd62b..405497c3e67 100644 --- a/gen/gamesconfiguration1_configuration/README.md +++ b/gen/gamesconfiguration1_configuration/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-gamesconfiguration1_configuration` library allows access to all features of the *Google Games Configuration* service. -This documentation was generated from *Games Configuration* crate version *0.1.4+20150325*, where *20150325* is the exact revision of the *gamesConfiguration:v1configuration* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *Games Configuration* crate version *0.1.5+20150325*, where *20150325* is the exact revision of the *gamesConfiguration:v1configuration* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *Games Configuration* *v1_configuration* API can be found at the [official documentation site](https://developers.google.com/games/services). diff --git a/gen/gamesconfiguration1_configuration/src/cmn.rs b/gen/gamesconfiguration1_configuration/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/gamesconfiguration1_configuration/src/cmn.rs +++ b/gen/gamesconfiguration1_configuration/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/gamesconfiguration1_configuration/src/lib.rs b/gen/gamesconfiguration1_configuration/src/lib.rs index 9b120915b01..25b9d88eb86 100644 --- a/gen/gamesconfiguration1_configuration/src/lib.rs +++ b/gen/gamesconfiguration1_configuration/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *Games Configuration* crate version *0.1.4+20150325*, where *20150325* is the exact revision of the *gamesConfiguration:v1configuration* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *Games Configuration* crate version *0.1.5+20150325*, where *20150325* is the exact revision of the *gamesConfiguration:v1configuration* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *Games Configuration* *v1_configuration* API can be found at the //! [official documentation site](https://developers.google.com/games/services). @@ -203,7 +203,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -296,40 +295,37 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct GamesConfiguration { +pub struct GamesConfiguration { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for GamesConfiguration {} +impl<'a, C, A> Hub for GamesConfiguration {} -impl<'a, C, NC, A> GamesConfiguration - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GamesConfiguration + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> GamesConfiguration { + pub fn new(client: C, authenticator: A) -> GamesConfiguration { GamesConfiguration { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn achievement_configurations(&'a self) -> AchievementConfigurationMethods<'a, C, NC, A> { + pub fn achievement_configurations(&'a self) -> AchievementConfigurationMethods<'a, C, A> { AchievementConfigurationMethods { hub: &self } } - pub fn image_configurations(&'a self) -> ImageConfigurationMethods<'a, C, NC, A> { + pub fn image_configurations(&'a self) -> ImageConfigurationMethods<'a, C, A> { ImageConfigurationMethods { hub: &self } } - pub fn leaderboard_configurations(&'a self) -> LeaderboardConfigurationMethods<'a, C, NC, A> { + pub fn leaderboard_configurations(&'a self) -> LeaderboardConfigurationMethods<'a, C, A> { LeaderboardConfigurationMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -674,15 +670,15 @@ impl Part for LeaderboardConfigurationDetail {} /// let rb = hub.image_configurations(); /// # } /// ``` -pub struct ImageConfigurationMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ImageConfigurationMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesConfiguration, + hub: &'a GamesConfiguration, } -impl<'a, C, NC, A> MethodsBuilder for ImageConfigurationMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ImageConfigurationMethods<'a, C, A> {} -impl<'a, C, NC, A> ImageConfigurationMethods<'a, C, NC, A> { +impl<'a, C, A> ImageConfigurationMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -692,7 +688,7 @@ impl<'a, C, NC, A> ImageConfigurationMethods<'a, C, NC, A> { /// /// * `resourceId` - The ID of the resource used by this method. /// * `imageType` - Selects which image in a resource for this method. - pub fn upload(&self, resource_id: &str, image_type: &str) -> ImageConfigurationUploadCall<'a, C, NC, A> { + pub fn upload(&self, resource_id: &str, image_type: &str) -> ImageConfigurationUploadCall<'a, C, A> { ImageConfigurationUploadCall { hub: self.hub, _resource_id: resource_id.to_string(), @@ -734,15 +730,15 @@ impl<'a, C, NC, A> ImageConfigurationMethods<'a, C, NC, A> { /// let rb = hub.achievement_configurations(); /// # } /// ``` -pub struct AchievementConfigurationMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AchievementConfigurationMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesConfiguration, + hub: &'a GamesConfiguration, } -impl<'a, C, NC, A> MethodsBuilder for AchievementConfigurationMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AchievementConfigurationMethods<'a, C, A> {} -impl<'a, C, NC, A> AchievementConfigurationMethods<'a, C, NC, A> { +impl<'a, C, A> AchievementConfigurationMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -751,7 +747,7 @@ impl<'a, C, NC, A> AchievementConfigurationMethods<'a, C, NC, A> { /// # Arguments /// /// * `applicationId` - The application ID from the Google Play developer console. - pub fn list(&self, application_id: &str) -> AchievementConfigurationListCall<'a, C, NC, A> { + pub fn list(&self, application_id: &str) -> AchievementConfigurationListCall<'a, C, A> { AchievementConfigurationListCall { hub: self.hub, _application_id: application_id.to_string(), @@ -771,7 +767,7 @@ impl<'a, C, NC, A> AchievementConfigurationMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `achievementId` - The ID of the achievement used by this method. - pub fn update(&self, request: &AchievementConfiguration, achievement_id: &str) -> AchievementConfigurationUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &AchievementConfiguration, achievement_id: &str) -> AchievementConfigurationUpdateCall<'a, C, A> { AchievementConfigurationUpdateCall { hub: self.hub, _request: request.clone(), @@ -790,7 +786,7 @@ impl<'a, C, NC, A> AchievementConfigurationMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `applicationId` - The application ID from the Google Play developer console. - pub fn insert(&self, request: &AchievementConfiguration, application_id: &str) -> AchievementConfigurationInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &AchievementConfiguration, application_id: &str) -> AchievementConfigurationInsertCall<'a, C, A> { AchievementConfigurationInsertCall { hub: self.hub, _request: request.clone(), @@ -808,7 +804,7 @@ impl<'a, C, NC, A> AchievementConfigurationMethods<'a, C, NC, A> { /// # Arguments /// /// * `achievementId` - The ID of the achievement used by this method. - pub fn get(&self, achievement_id: &str) -> AchievementConfigurationGetCall<'a, C, NC, A> { + pub fn get(&self, achievement_id: &str) -> AchievementConfigurationGetCall<'a, C, A> { AchievementConfigurationGetCall { hub: self.hub, _achievement_id: achievement_id.to_string(), @@ -826,7 +822,7 @@ impl<'a, C, NC, A> AchievementConfigurationMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `achievementId` - The ID of the achievement used by this method. - pub fn patch(&self, request: &AchievementConfiguration, achievement_id: &str) -> AchievementConfigurationPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &AchievementConfiguration, achievement_id: &str) -> AchievementConfigurationPatchCall<'a, C, A> { AchievementConfigurationPatchCall { hub: self.hub, _request: request.clone(), @@ -844,7 +840,7 @@ impl<'a, C, NC, A> AchievementConfigurationMethods<'a, C, NC, A> { /// # Arguments /// /// * `achievementId` - The ID of the achievement used by this method. - pub fn delete(&self, achievement_id: &str) -> AchievementConfigurationDeleteCall<'a, C, NC, A> { + pub fn delete(&self, achievement_id: &str) -> AchievementConfigurationDeleteCall<'a, C, A> { AchievementConfigurationDeleteCall { hub: self.hub, _achievement_id: achievement_id.to_string(), @@ -885,15 +881,15 @@ impl<'a, C, NC, A> AchievementConfigurationMethods<'a, C, NC, A> { /// let rb = hub.leaderboard_configurations(); /// # } /// ``` -pub struct LeaderboardConfigurationMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LeaderboardConfigurationMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesConfiguration, + hub: &'a GamesConfiguration, } -impl<'a, C, NC, A> MethodsBuilder for LeaderboardConfigurationMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for LeaderboardConfigurationMethods<'a, C, A> {} -impl<'a, C, NC, A> LeaderboardConfigurationMethods<'a, C, NC, A> { +impl<'a, C, A> LeaderboardConfigurationMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -903,7 +899,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `applicationId` - The application ID from the Google Play developer console. - pub fn insert(&self, request: &LeaderboardConfiguration, application_id: &str) -> LeaderboardConfigurationInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &LeaderboardConfiguration, application_id: &str) -> LeaderboardConfigurationInsertCall<'a, C, A> { LeaderboardConfigurationInsertCall { hub: self.hub, _request: request.clone(), @@ -921,7 +917,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationMethods<'a, C, NC, A> { /// # Arguments /// /// * `leaderboardId` - The ID of the leaderboard. - pub fn get(&self, leaderboard_id: &str) -> LeaderboardConfigurationGetCall<'a, C, NC, A> { + pub fn get(&self, leaderboard_id: &str) -> LeaderboardConfigurationGetCall<'a, C, A> { LeaderboardConfigurationGetCall { hub: self.hub, _leaderboard_id: leaderboard_id.to_string(), @@ -939,7 +935,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `leaderboardId` - The ID of the leaderboard. - pub fn patch(&self, request: &LeaderboardConfiguration, leaderboard_id: &str) -> LeaderboardConfigurationPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &LeaderboardConfiguration, leaderboard_id: &str) -> LeaderboardConfigurationPatchCall<'a, C, A> { LeaderboardConfigurationPatchCall { hub: self.hub, _request: request.clone(), @@ -958,7 +954,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `leaderboardId` - The ID of the leaderboard. - pub fn update(&self, request: &LeaderboardConfiguration, leaderboard_id: &str) -> LeaderboardConfigurationUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &LeaderboardConfiguration, leaderboard_id: &str) -> LeaderboardConfigurationUpdateCall<'a, C, A> { LeaderboardConfigurationUpdateCall { hub: self.hub, _request: request.clone(), @@ -976,7 +972,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationMethods<'a, C, NC, A> { /// # Arguments /// /// * `applicationId` - The application ID from the Google Play developer console. - pub fn list(&self, application_id: &str) -> LeaderboardConfigurationListCall<'a, C, NC, A> { + pub fn list(&self, application_id: &str) -> LeaderboardConfigurationListCall<'a, C, A> { LeaderboardConfigurationListCall { hub: self.hub, _application_id: application_id.to_string(), @@ -995,7 +991,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationMethods<'a, C, NC, A> { /// # Arguments /// /// * `leaderboardId` - The ID of the leaderboard. - pub fn delete(&self, leaderboard_id: &str) -> LeaderboardConfigurationDeleteCall<'a, C, NC, A> { + pub fn delete(&self, leaderboard_id: &str) -> LeaderboardConfigurationDeleteCall<'a, C, A> { LeaderboardConfigurationDeleteCall { hub: self.hub, _leaderboard_id: leaderboard_id.to_string(), @@ -1045,10 +1041,10 @@ impl<'a, C, NC, A> LeaderboardConfigurationMethods<'a, C, NC, A> { /// .upload(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct ImageConfigurationUploadCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ImageConfigurationUploadCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesConfiguration, + hub: &'a GamesConfiguration, _resource_id: String, _image_type: String, _delegate: Option<&'a mut Delegate>, @@ -1056,9 +1052,9 @@ pub struct ImageConfigurationUploadCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ImageConfigurationUploadCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ImageConfigurationUploadCall<'a, C, A> {} -impl<'a, C, NC, A> ImageConfigurationUploadCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ImageConfigurationUploadCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1300,7 +1296,7 @@ impl<'a, C, NC, A> ImageConfigurationUploadCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The ID of the resource used by this method. - pub fn resource_id(mut self, new_value: &str) -> ImageConfigurationUploadCall<'a, C, NC, A> { + pub fn resource_id(mut self, new_value: &str) -> ImageConfigurationUploadCall<'a, C, A> { self._resource_id = new_value.to_string(); self } @@ -1310,7 +1306,7 @@ impl<'a, C, NC, A> ImageConfigurationUploadCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Selects which image in a resource for this method. - pub fn image_type(mut self, new_value: &str) -> ImageConfigurationUploadCall<'a, C, NC, A> { + pub fn image_type(mut self, new_value: &str) -> ImageConfigurationUploadCall<'a, C, A> { self._image_type = new_value.to_string(); self } @@ -1321,7 +1317,7 @@ impl<'a, C, NC, A> ImageConfigurationUploadCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ImageConfigurationUploadCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ImageConfigurationUploadCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1342,7 +1338,7 @@ impl<'a, C, NC, A> ImageConfigurationUploadCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ImageConfigurationUploadCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ImageConfigurationUploadCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1359,7 +1355,7 @@ impl<'a, C, NC, A> ImageConfigurationUploadCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ImageConfigurationUploadCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ImageConfigurationUploadCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1399,10 +1395,10 @@ impl<'a, C, NC, A> ImageConfigurationUploadCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct AchievementConfigurationListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AchievementConfigurationListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesConfiguration, + hub: &'a GamesConfiguration, _application_id: String, _page_token: Option, _max_results: Option, @@ -1411,9 +1407,9 @@ pub struct AchievementConfigurationListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AchievementConfigurationListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AchievementConfigurationListCall<'a, C, A> {} -impl<'a, C, NC, A> AchievementConfigurationListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AchievementConfigurationListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1551,7 +1547,7 @@ impl<'a, C, NC, A> AchievementConfigurationListCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// The application ID from the Google Play developer console. - pub fn application_id(mut self, new_value: &str) -> AchievementConfigurationListCall<'a, C, NC, A> { + pub fn application_id(mut self, new_value: &str) -> AchievementConfigurationListCall<'a, C, A> { self._application_id = new_value.to_string(); self } @@ -1559,7 +1555,7 @@ impl<'a, C, NC, A> AchievementConfigurationListCall<'a, C, NC, A> where NC: hype /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> AchievementConfigurationListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AchievementConfigurationListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -1567,7 +1563,7 @@ impl<'a, C, NC, A> AchievementConfigurationListCall<'a, C, NC, A> where NC: hype /// /// /// The maximum number of resource configurations to return in the response, used for paging. For any response, the actual number of resources returned may be less than the specified maxResults. - pub fn max_results(mut self, new_value: i32) -> AchievementConfigurationListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> AchievementConfigurationListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -1578,7 +1574,7 @@ impl<'a, C, NC, A> AchievementConfigurationListCall<'a, C, NC, A> where NC: hype /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementConfigurationListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementConfigurationListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1599,7 +1595,7 @@ impl<'a, C, NC, A> AchievementConfigurationListCall<'a, C, NC, A> where NC: hype /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AchievementConfigurationListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AchievementConfigurationListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1616,7 +1612,7 @@ impl<'a, C, NC, A> AchievementConfigurationListCall<'a, C, NC, A> where NC: hype /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AchievementConfigurationListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AchievementConfigurationListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1660,10 +1656,10 @@ impl<'a, C, NC, A> AchievementConfigurationListCall<'a, C, NC, A> where NC: hype /// .doit(); /// # } /// ``` -pub struct AchievementConfigurationUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AchievementConfigurationUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesConfiguration, + hub: &'a GamesConfiguration, _request: AchievementConfiguration, _achievement_id: String, _delegate: Option<&'a mut Delegate>, @@ -1671,9 +1667,9 @@ pub struct AchievementConfigurationUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AchievementConfigurationUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AchievementConfigurationUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AchievementConfigurationUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AchievementConfigurationUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1812,7 +1808,7 @@ impl<'a, C, NC, A> AchievementConfigurationUpdateCall<'a, C, NC, A> where NC: hy /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AchievementConfiguration) -> AchievementConfigurationUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AchievementConfiguration) -> AchievementConfigurationUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1822,7 +1818,7 @@ impl<'a, C, NC, A> AchievementConfigurationUpdateCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// The ID of the achievement used by this method. - pub fn achievement_id(mut self, new_value: &str) -> AchievementConfigurationUpdateCall<'a, C, NC, A> { + pub fn achievement_id(mut self, new_value: &str) -> AchievementConfigurationUpdateCall<'a, C, A> { self._achievement_id = new_value.to_string(); self } @@ -1833,7 +1829,7 @@ impl<'a, C, NC, A> AchievementConfigurationUpdateCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementConfigurationUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementConfigurationUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1854,7 +1850,7 @@ impl<'a, C, NC, A> AchievementConfigurationUpdateCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AchievementConfigurationUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AchievementConfigurationUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1871,7 +1867,7 @@ impl<'a, C, NC, A> AchievementConfigurationUpdateCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AchievementConfigurationUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AchievementConfigurationUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1915,10 +1911,10 @@ impl<'a, C, NC, A> AchievementConfigurationUpdateCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct AchievementConfigurationInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AchievementConfigurationInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesConfiguration, + hub: &'a GamesConfiguration, _request: AchievementConfiguration, _application_id: String, _delegate: Option<&'a mut Delegate>, @@ -1926,9 +1922,9 @@ pub struct AchievementConfigurationInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AchievementConfigurationInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AchievementConfigurationInsertCall<'a, C, A> {} -impl<'a, C, NC, A> AchievementConfigurationInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AchievementConfigurationInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2067,7 +2063,7 @@ impl<'a, C, NC, A> AchievementConfigurationInsertCall<'a, C, NC, A> where NC: hy /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AchievementConfiguration) -> AchievementConfigurationInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AchievementConfiguration) -> AchievementConfigurationInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2077,7 +2073,7 @@ impl<'a, C, NC, A> AchievementConfigurationInsertCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// The application ID from the Google Play developer console. - pub fn application_id(mut self, new_value: &str) -> AchievementConfigurationInsertCall<'a, C, NC, A> { + pub fn application_id(mut self, new_value: &str) -> AchievementConfigurationInsertCall<'a, C, A> { self._application_id = new_value.to_string(); self } @@ -2088,7 +2084,7 @@ impl<'a, C, NC, A> AchievementConfigurationInsertCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementConfigurationInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementConfigurationInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2109,7 +2105,7 @@ impl<'a, C, NC, A> AchievementConfigurationInsertCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AchievementConfigurationInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AchievementConfigurationInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2126,7 +2122,7 @@ impl<'a, C, NC, A> AchievementConfigurationInsertCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AchievementConfigurationInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AchievementConfigurationInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2164,19 +2160,19 @@ impl<'a, C, NC, A> AchievementConfigurationInsertCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct AchievementConfigurationGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AchievementConfigurationGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesConfiguration, + hub: &'a GamesConfiguration, _achievement_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AchievementConfigurationGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AchievementConfigurationGetCall<'a, C, A> {} -impl<'a, C, NC, A> AchievementConfigurationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AchievementConfigurationGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2308,7 +2304,7 @@ impl<'a, C, NC, A> AchievementConfigurationGetCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The ID of the achievement used by this method. - pub fn achievement_id(mut self, new_value: &str) -> AchievementConfigurationGetCall<'a, C, NC, A> { + pub fn achievement_id(mut self, new_value: &str) -> AchievementConfigurationGetCall<'a, C, A> { self._achievement_id = new_value.to_string(); self } @@ -2319,7 +2315,7 @@ impl<'a, C, NC, A> AchievementConfigurationGetCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementConfigurationGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementConfigurationGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2340,7 +2336,7 @@ impl<'a, C, NC, A> AchievementConfigurationGetCall<'a, C, NC, A> where NC: hyper /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AchievementConfigurationGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AchievementConfigurationGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2357,7 +2353,7 @@ impl<'a, C, NC, A> AchievementConfigurationGetCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AchievementConfigurationGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AchievementConfigurationGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2401,10 +2397,10 @@ impl<'a, C, NC, A> AchievementConfigurationGetCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct AchievementConfigurationPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AchievementConfigurationPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesConfiguration, + hub: &'a GamesConfiguration, _request: AchievementConfiguration, _achievement_id: String, _delegate: Option<&'a mut Delegate>, @@ -2412,9 +2408,9 @@ pub struct AchievementConfigurationPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AchievementConfigurationPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AchievementConfigurationPatchCall<'a, C, A> {} -impl<'a, C, NC, A> AchievementConfigurationPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AchievementConfigurationPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2553,7 +2549,7 @@ impl<'a, C, NC, A> AchievementConfigurationPatchCall<'a, C, NC, A> where NC: hyp /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AchievementConfiguration) -> AchievementConfigurationPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AchievementConfiguration) -> AchievementConfigurationPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2563,7 +2559,7 @@ impl<'a, C, NC, A> AchievementConfigurationPatchCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// The ID of the achievement used by this method. - pub fn achievement_id(mut self, new_value: &str) -> AchievementConfigurationPatchCall<'a, C, NC, A> { + pub fn achievement_id(mut self, new_value: &str) -> AchievementConfigurationPatchCall<'a, C, A> { self._achievement_id = new_value.to_string(); self } @@ -2574,7 +2570,7 @@ impl<'a, C, NC, A> AchievementConfigurationPatchCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementConfigurationPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementConfigurationPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2595,7 +2591,7 @@ impl<'a, C, NC, A> AchievementConfigurationPatchCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AchievementConfigurationPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AchievementConfigurationPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2612,7 +2608,7 @@ impl<'a, C, NC, A> AchievementConfigurationPatchCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AchievementConfigurationPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AchievementConfigurationPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2650,19 +2646,19 @@ impl<'a, C, NC, A> AchievementConfigurationPatchCall<'a, C, NC, A> where NC: hyp /// .doit(); /// # } /// ``` -pub struct AchievementConfigurationDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AchievementConfigurationDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesConfiguration, + hub: &'a GamesConfiguration, _achievement_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AchievementConfigurationDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AchievementConfigurationDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> AchievementConfigurationDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AchievementConfigurationDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2783,7 +2779,7 @@ impl<'a, C, NC, A> AchievementConfigurationDeleteCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// The ID of the achievement used by this method. - pub fn achievement_id(mut self, new_value: &str) -> AchievementConfigurationDeleteCall<'a, C, NC, A> { + pub fn achievement_id(mut self, new_value: &str) -> AchievementConfigurationDeleteCall<'a, C, A> { self._achievement_id = new_value.to_string(); self } @@ -2794,7 +2790,7 @@ impl<'a, C, NC, A> AchievementConfigurationDeleteCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementConfigurationDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementConfigurationDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2815,7 +2811,7 @@ impl<'a, C, NC, A> AchievementConfigurationDeleteCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AchievementConfigurationDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AchievementConfigurationDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2832,7 +2828,7 @@ impl<'a, C, NC, A> AchievementConfigurationDeleteCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AchievementConfigurationDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AchievementConfigurationDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2876,10 +2872,10 @@ impl<'a, C, NC, A> AchievementConfigurationDeleteCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct LeaderboardConfigurationInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LeaderboardConfigurationInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesConfiguration, + hub: &'a GamesConfiguration, _request: LeaderboardConfiguration, _application_id: String, _delegate: Option<&'a mut Delegate>, @@ -2887,9 +2883,9 @@ pub struct LeaderboardConfigurationInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LeaderboardConfigurationInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LeaderboardConfigurationInsertCall<'a, C, A> {} -impl<'a, C, NC, A> LeaderboardConfigurationInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LeaderboardConfigurationInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3028,7 +3024,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationInsertCall<'a, C, NC, A> where NC: hy /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &LeaderboardConfiguration) -> LeaderboardConfigurationInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &LeaderboardConfiguration) -> LeaderboardConfigurationInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3038,7 +3034,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationInsertCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// The application ID from the Google Play developer console. - pub fn application_id(mut self, new_value: &str) -> LeaderboardConfigurationInsertCall<'a, C, NC, A> { + pub fn application_id(mut self, new_value: &str) -> LeaderboardConfigurationInsertCall<'a, C, A> { self._application_id = new_value.to_string(); self } @@ -3049,7 +3045,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationInsertCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LeaderboardConfigurationInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LeaderboardConfigurationInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3070,7 +3066,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationInsertCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LeaderboardConfigurationInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LeaderboardConfigurationInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3087,7 +3083,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationInsertCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LeaderboardConfigurationInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LeaderboardConfigurationInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3125,19 +3121,19 @@ impl<'a, C, NC, A> LeaderboardConfigurationInsertCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct LeaderboardConfigurationGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LeaderboardConfigurationGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesConfiguration, + hub: &'a GamesConfiguration, _leaderboard_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LeaderboardConfigurationGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LeaderboardConfigurationGetCall<'a, C, A> {} -impl<'a, C, NC, A> LeaderboardConfigurationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LeaderboardConfigurationGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3269,7 +3265,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationGetCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The ID of the leaderboard. - pub fn leaderboard_id(mut self, new_value: &str) -> LeaderboardConfigurationGetCall<'a, C, NC, A> { + pub fn leaderboard_id(mut self, new_value: &str) -> LeaderboardConfigurationGetCall<'a, C, A> { self._leaderboard_id = new_value.to_string(); self } @@ -3280,7 +3276,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationGetCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LeaderboardConfigurationGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LeaderboardConfigurationGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3301,7 +3297,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationGetCall<'a, C, NC, A> where NC: hyper /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LeaderboardConfigurationGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LeaderboardConfigurationGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3318,7 +3314,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationGetCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LeaderboardConfigurationGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LeaderboardConfigurationGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3362,10 +3358,10 @@ impl<'a, C, NC, A> LeaderboardConfigurationGetCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct LeaderboardConfigurationPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LeaderboardConfigurationPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesConfiguration, + hub: &'a GamesConfiguration, _request: LeaderboardConfiguration, _leaderboard_id: String, _delegate: Option<&'a mut Delegate>, @@ -3373,9 +3369,9 @@ pub struct LeaderboardConfigurationPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LeaderboardConfigurationPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LeaderboardConfigurationPatchCall<'a, C, A> {} -impl<'a, C, NC, A> LeaderboardConfigurationPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LeaderboardConfigurationPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3514,7 +3510,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationPatchCall<'a, C, NC, A> where NC: hyp /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &LeaderboardConfiguration) -> LeaderboardConfigurationPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &LeaderboardConfiguration) -> LeaderboardConfigurationPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3524,7 +3520,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationPatchCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// The ID of the leaderboard. - pub fn leaderboard_id(mut self, new_value: &str) -> LeaderboardConfigurationPatchCall<'a, C, NC, A> { + pub fn leaderboard_id(mut self, new_value: &str) -> LeaderboardConfigurationPatchCall<'a, C, A> { self._leaderboard_id = new_value.to_string(); self } @@ -3535,7 +3531,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationPatchCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LeaderboardConfigurationPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LeaderboardConfigurationPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3556,7 +3552,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationPatchCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LeaderboardConfigurationPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LeaderboardConfigurationPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3573,7 +3569,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationPatchCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LeaderboardConfigurationPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LeaderboardConfigurationPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3617,10 +3613,10 @@ impl<'a, C, NC, A> LeaderboardConfigurationPatchCall<'a, C, NC, A> where NC: hyp /// .doit(); /// # } /// ``` -pub struct LeaderboardConfigurationUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LeaderboardConfigurationUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesConfiguration, + hub: &'a GamesConfiguration, _request: LeaderboardConfiguration, _leaderboard_id: String, _delegate: Option<&'a mut Delegate>, @@ -3628,9 +3624,9 @@ pub struct LeaderboardConfigurationUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LeaderboardConfigurationUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LeaderboardConfigurationUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> LeaderboardConfigurationUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LeaderboardConfigurationUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3769,7 +3765,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationUpdateCall<'a, C, NC, A> where NC: hy /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &LeaderboardConfiguration) -> LeaderboardConfigurationUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &LeaderboardConfiguration) -> LeaderboardConfigurationUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3779,7 +3775,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationUpdateCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// The ID of the leaderboard. - pub fn leaderboard_id(mut self, new_value: &str) -> LeaderboardConfigurationUpdateCall<'a, C, NC, A> { + pub fn leaderboard_id(mut self, new_value: &str) -> LeaderboardConfigurationUpdateCall<'a, C, A> { self._leaderboard_id = new_value.to_string(); self } @@ -3790,7 +3786,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationUpdateCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LeaderboardConfigurationUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LeaderboardConfigurationUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3811,7 +3807,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationUpdateCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LeaderboardConfigurationUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LeaderboardConfigurationUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3828,7 +3824,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationUpdateCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LeaderboardConfigurationUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LeaderboardConfigurationUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3868,10 +3864,10 @@ impl<'a, C, NC, A> LeaderboardConfigurationUpdateCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct LeaderboardConfigurationListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LeaderboardConfigurationListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesConfiguration, + hub: &'a GamesConfiguration, _application_id: String, _page_token: Option, _max_results: Option, @@ -3880,9 +3876,9 @@ pub struct LeaderboardConfigurationListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LeaderboardConfigurationListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LeaderboardConfigurationListCall<'a, C, A> {} -impl<'a, C, NC, A> LeaderboardConfigurationListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LeaderboardConfigurationListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4020,7 +4016,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationListCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// The application ID from the Google Play developer console. - pub fn application_id(mut self, new_value: &str) -> LeaderboardConfigurationListCall<'a, C, NC, A> { + pub fn application_id(mut self, new_value: &str) -> LeaderboardConfigurationListCall<'a, C, A> { self._application_id = new_value.to_string(); self } @@ -4028,7 +4024,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationListCall<'a, C, NC, A> where NC: hype /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> LeaderboardConfigurationListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> LeaderboardConfigurationListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -4036,7 +4032,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationListCall<'a, C, NC, A> where NC: hype /// /// /// The maximum number of resource configurations to return in the response, used for paging. For any response, the actual number of resources returned may be less than the specified maxResults. - pub fn max_results(mut self, new_value: i32) -> LeaderboardConfigurationListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> LeaderboardConfigurationListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -4047,7 +4043,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationListCall<'a, C, NC, A> where NC: hype /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LeaderboardConfigurationListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LeaderboardConfigurationListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4068,7 +4064,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationListCall<'a, C, NC, A> where NC: hype /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LeaderboardConfigurationListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LeaderboardConfigurationListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4085,7 +4081,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationListCall<'a, C, NC, A> where NC: hype /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LeaderboardConfigurationListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LeaderboardConfigurationListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4123,19 +4119,19 @@ impl<'a, C, NC, A> LeaderboardConfigurationListCall<'a, C, NC, A> where NC: hype /// .doit(); /// # } /// ``` -pub struct LeaderboardConfigurationDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LeaderboardConfigurationDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesConfiguration, + hub: &'a GamesConfiguration, _leaderboard_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LeaderboardConfigurationDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LeaderboardConfigurationDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> LeaderboardConfigurationDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LeaderboardConfigurationDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4256,7 +4252,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationDeleteCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// The ID of the leaderboard. - pub fn leaderboard_id(mut self, new_value: &str) -> LeaderboardConfigurationDeleteCall<'a, C, NC, A> { + pub fn leaderboard_id(mut self, new_value: &str) -> LeaderboardConfigurationDeleteCall<'a, C, A> { self._leaderboard_id = new_value.to_string(); self } @@ -4267,7 +4263,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationDeleteCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LeaderboardConfigurationDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LeaderboardConfigurationDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4288,7 +4284,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationDeleteCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LeaderboardConfigurationDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LeaderboardConfigurationDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4305,7 +4301,7 @@ impl<'a, C, NC, A> LeaderboardConfigurationDeleteCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LeaderboardConfigurationDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LeaderboardConfigurationDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/gamesmanagement1_management/Cargo.toml b/gen/gamesmanagement1_management/Cargo.toml index 6339cd52f86..c6ffbfd2afb 100644 --- a/gen/gamesmanagement1_management/Cargo.toml +++ b/gen/gamesmanagement1_management/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-gamesmanagement1_management" -version = "0.1.4+20150325" +version = "0.1.5+20150325" authors = ["Sebastian Thiel "] description = "A complete library to interact with Games Management (protocol v1management)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/gamesmanagement1_management" homepage = "https://developers.google.com/games/services" -documentation = "http://byron.github.io/google-apis-rs/google-gamesmanagement1_management" +documentation = "http://byron.github.io/google-apis-rs/google_gamesmanagement1_management" license = "MIT" keywords = ["gamesManagement", "google", "protocol", "web", "api"] diff --git a/gen/gamesmanagement1_management/README.md b/gen/gamesmanagement1_management/README.md index 471916545e4..4b7b1f2437b 100644 --- a/gen/gamesmanagement1_management/README.md +++ b/gen/gamesmanagement1_management/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-gamesmanagement1_management` library allows access to all features of the *Google Games Management* service. -This documentation was generated from *Games Management* crate version *0.1.4+20150325*, where *20150325* is the exact revision of the *gamesManagement:v1management* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *Games Management* crate version *0.1.5+20150325*, where *20150325* is the exact revision of the *gamesManagement:v1management* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *Games Management* *v1_management* API can be found at the [official documentation site](https://developers.google.com/games/services). diff --git a/gen/gamesmanagement1_management/src/cmn.rs b/gen/gamesmanagement1_management/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/gamesmanagement1_management/src/cmn.rs +++ b/gen/gamesmanagement1_management/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/gamesmanagement1_management/src/lib.rs b/gen/gamesmanagement1_management/src/lib.rs index 4e9f3e7e3a1..d3dc02c8a01 100644 --- a/gen/gamesmanagement1_management/src/lib.rs +++ b/gen/gamesmanagement1_management/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *Games Management* crate version *0.1.4+20150325*, where *20150325* is the exact revision of the *gamesManagement:v1management* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *Games Management* crate version *0.1.5+20150325*, where *20150325* is the exact revision of the *gamesManagement:v1management* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *Games Management* *v1_management* API can be found at the //! [official documentation site](https://developers.google.com/games/services). @@ -203,7 +203,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -298,55 +297,52 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct GamesManagement { +pub struct GamesManagement { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for GamesManagement {} +impl<'a, C, A> Hub for GamesManagement {} -impl<'a, C, NC, A> GamesManagement - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GamesManagement + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> GamesManagement { + pub fn new(client: C, authenticator: A) -> GamesManagement { GamesManagement { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn achievements(&'a self) -> AchievementMethods<'a, C, NC, A> { + pub fn achievements(&'a self) -> AchievementMethods<'a, C, A> { AchievementMethods { hub: &self } } - pub fn applications(&'a self) -> ApplicationMethods<'a, C, NC, A> { + pub fn applications(&'a self) -> ApplicationMethods<'a, C, A> { ApplicationMethods { hub: &self } } - pub fn events(&'a self) -> EventMethods<'a, C, NC, A> { + pub fn events(&'a self) -> EventMethods<'a, C, A> { EventMethods { hub: &self } } - pub fn players(&'a self) -> PlayerMethods<'a, C, NC, A> { + pub fn players(&'a self) -> PlayerMethods<'a, C, A> { PlayerMethods { hub: &self } } - pub fn quests(&'a self) -> QuestMethods<'a, C, NC, A> { + pub fn quests(&'a self) -> QuestMethods<'a, C, A> { QuestMethods { hub: &self } } - pub fn rooms(&'a self) -> RoomMethods<'a, C, NC, A> { + pub fn rooms(&'a self) -> RoomMethods<'a, C, A> { RoomMethods { hub: &self } } - pub fn scores(&'a self) -> ScoreMethods<'a, C, NC, A> { + pub fn scores(&'a self) -> ScoreMethods<'a, C, A> { ScoreMethods { hub: &self } } - pub fn turn_based_matches(&'a self) -> TurnBasedMatcheMethods<'a, C, NC, A> { + pub fn turn_based_matches(&'a self) -> TurnBasedMatcheMethods<'a, C, A> { TurnBasedMatcheMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -728,20 +724,20 @@ impl Part for HiddenPlayer {} /// let rb = hub.achievements(); /// # } /// ``` -pub struct AchievementMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AchievementMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, } -impl<'a, C, NC, A> MethodsBuilder for AchievementMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AchievementMethods<'a, C, A> {} -impl<'a, C, NC, A> AchievementMethods<'a, C, NC, A> { +impl<'a, C, A> AchievementMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Resets all draft achievements for all players. This method is only available to user accounts for your developer console. - pub fn reset_all_for_all_players(&self) -> AchievementResetAllForAllPlayerCall<'a, C, NC, A> { + pub fn reset_all_for_all_players(&self) -> AchievementResetAllForAllPlayerCall<'a, C, A> { AchievementResetAllForAllPlayerCall { hub: self.hub, _delegate: Default::default(), @@ -757,7 +753,7 @@ impl<'a, C, NC, A> AchievementMethods<'a, C, NC, A> { /// # Arguments /// /// * `achievementId` - The ID of the achievement used by this method. - pub fn reset_for_all_players(&self, achievement_id: &str) -> AchievementResetForAllPlayerCall<'a, C, NC, A> { + pub fn reset_for_all_players(&self, achievement_id: &str) -> AchievementResetForAllPlayerCall<'a, C, A> { AchievementResetForAllPlayerCall { hub: self.hub, _achievement_id: achievement_id.to_string(), @@ -774,7 +770,7 @@ impl<'a, C, NC, A> AchievementMethods<'a, C, NC, A> { /// # Arguments /// /// * `achievementId` - The ID of the achievement used by this method. - pub fn reset(&self, achievement_id: &str) -> AchievementResetCall<'a, C, NC, A> { + pub fn reset(&self, achievement_id: &str) -> AchievementResetCall<'a, C, A> { AchievementResetCall { hub: self.hub, _achievement_id: achievement_id.to_string(), @@ -791,7 +787,7 @@ impl<'a, C, NC, A> AchievementMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn reset_multiple_for_all_players(&self, request: &AchievementResetMultipleForAllRequest) -> AchievementResetMultipleForAllPlayerCall<'a, C, NC, A> { + pub fn reset_multiple_for_all_players(&self, request: &AchievementResetMultipleForAllRequest) -> AchievementResetMultipleForAllPlayerCall<'a, C, A> { AchievementResetMultipleForAllPlayerCall { hub: self.hub, _request: request.clone(), @@ -804,7 +800,7 @@ impl<'a, C, NC, A> AchievementMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Resets all achievements for the currently authenticated player for your application. This method is only accessible to whitelisted tester accounts for your application. - pub fn reset_all(&self) -> AchievementResetAllCall<'a, C, NC, A> { + pub fn reset_all(&self) -> AchievementResetAllCall<'a, C, A> { AchievementResetAllCall { hub: self.hub, _delegate: Default::default(), @@ -844,15 +840,15 @@ impl<'a, C, NC, A> AchievementMethods<'a, C, NC, A> { /// let rb = hub.players(); /// # } /// ``` -pub struct PlayerMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlayerMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, } -impl<'a, C, NC, A> MethodsBuilder for PlayerMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PlayerMethods<'a, C, A> {} -impl<'a, C, NC, A> PlayerMethods<'a, C, NC, A> { +impl<'a, C, A> PlayerMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -862,7 +858,7 @@ impl<'a, C, NC, A> PlayerMethods<'a, C, NC, A> { /// /// * `applicationId` - The application ID from the Google Play developer console. /// * `playerId` - A player ID. A value of me may be used in place of the authenticated player's ID. - pub fn hide(&self, application_id: &str, player_id: &str) -> PlayerHideCall<'a, C, NC, A> { + pub fn hide(&self, application_id: &str, player_id: &str) -> PlayerHideCall<'a, C, A> { PlayerHideCall { hub: self.hub, _application_id: application_id.to_string(), @@ -881,7 +877,7 @@ impl<'a, C, NC, A> PlayerMethods<'a, C, NC, A> { /// /// * `applicationId` - The application ID from the Google Play developer console. /// * `playerId` - A player ID. A value of me may be used in place of the authenticated player's ID. - pub fn unhide(&self, application_id: &str, player_id: &str) -> PlayerUnhideCall<'a, C, NC, A> { + pub fn unhide(&self, application_id: &str, player_id: &str) -> PlayerUnhideCall<'a, C, A> { PlayerUnhideCall { hub: self.hub, _application_id: application_id.to_string(), @@ -923,15 +919,15 @@ impl<'a, C, NC, A> PlayerMethods<'a, C, NC, A> { /// let rb = hub.scores(); /// # } /// ``` -pub struct ScoreMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ScoreMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, } -impl<'a, C, NC, A> MethodsBuilder for ScoreMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ScoreMethods<'a, C, A> {} -impl<'a, C, NC, A> ScoreMethods<'a, C, NC, A> { +impl<'a, C, A> ScoreMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -940,7 +936,7 @@ impl<'a, C, NC, A> ScoreMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn reset_multiple_for_all_players(&self, request: &ScoresResetMultipleForAllRequest) -> ScoreResetMultipleForAllPlayerCall<'a, C, NC, A> { + pub fn reset_multiple_for_all_players(&self, request: &ScoresResetMultipleForAllRequest) -> ScoreResetMultipleForAllPlayerCall<'a, C, A> { ScoreResetMultipleForAllPlayerCall { hub: self.hub, _request: request.clone(), @@ -953,7 +949,7 @@ impl<'a, C, NC, A> ScoreMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Resets scores for all draft leaderboards for all players. This method is only available to user accounts for your developer console. - pub fn reset_all_for_all_players(&self) -> ScoreResetAllForAllPlayerCall<'a, C, NC, A> { + pub fn reset_all_for_all_players(&self) -> ScoreResetAllForAllPlayerCall<'a, C, A> { ScoreResetAllForAllPlayerCall { hub: self.hub, _delegate: Default::default(), @@ -965,7 +961,7 @@ impl<'a, C, NC, A> ScoreMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Resets all scores for all leaderboards for the currently authenticated players. This method is only accessible to whitelisted tester accounts for your application. - pub fn reset_all(&self) -> ScoreResetAllCall<'a, C, NC, A> { + pub fn reset_all(&self) -> ScoreResetAllCall<'a, C, A> { ScoreResetAllCall { hub: self.hub, _delegate: Default::default(), @@ -981,7 +977,7 @@ impl<'a, C, NC, A> ScoreMethods<'a, C, NC, A> { /// # Arguments /// /// * `leaderboardId` - The ID of the leaderboard. - pub fn reset_for_all_players(&self, leaderboard_id: &str) -> ScoreResetForAllPlayerCall<'a, C, NC, A> { + pub fn reset_for_all_players(&self, leaderboard_id: &str) -> ScoreResetForAllPlayerCall<'a, C, A> { ScoreResetForAllPlayerCall { hub: self.hub, _leaderboard_id: leaderboard_id.to_string(), @@ -998,7 +994,7 @@ impl<'a, C, NC, A> ScoreMethods<'a, C, NC, A> { /// # Arguments /// /// * `leaderboardId` - The ID of the leaderboard. - pub fn reset(&self, leaderboard_id: &str) -> ScoreResetCall<'a, C, NC, A> { + pub fn reset(&self, leaderboard_id: &str) -> ScoreResetCall<'a, C, A> { ScoreResetCall { hub: self.hub, _leaderboard_id: leaderboard_id.to_string(), @@ -1039,20 +1035,20 @@ impl<'a, C, NC, A> ScoreMethods<'a, C, NC, A> { /// let rb = hub.turn_based_matches(); /// # } /// ``` -pub struct TurnBasedMatcheMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TurnBasedMatcheMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, } -impl<'a, C, NC, A> MethodsBuilder for TurnBasedMatcheMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TurnBasedMatcheMethods<'a, C, A> {} -impl<'a, C, NC, A> TurnBasedMatcheMethods<'a, C, NC, A> { +impl<'a, C, A> TurnBasedMatcheMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Reset all turn-based match data for a user. This method is only accessible to whitelisted tester accounts for your application. - pub fn reset(&self) -> TurnBasedMatcheResetCall<'a, C, NC, A> { + pub fn reset(&self) -> TurnBasedMatcheResetCall<'a, C, A> { TurnBasedMatcheResetCall { hub: self.hub, _delegate: Default::default(), @@ -1064,7 +1060,7 @@ impl<'a, C, NC, A> TurnBasedMatcheMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Deletes turn-based matches where the only match participants are from whitelisted tester accounts for your application. This method is only available to user accounts for your developer console. - pub fn reset_for_all_players(&self) -> TurnBasedMatcheResetForAllPlayerCall<'a, C, NC, A> { + pub fn reset_for_all_players(&self) -> TurnBasedMatcheResetForAllPlayerCall<'a, C, A> { TurnBasedMatcheResetForAllPlayerCall { hub: self.hub, _delegate: Default::default(), @@ -1104,15 +1100,15 @@ impl<'a, C, NC, A> TurnBasedMatcheMethods<'a, C, NC, A> { /// let rb = hub.applications(); /// # } /// ``` -pub struct ApplicationMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ApplicationMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, } -impl<'a, C, NC, A> MethodsBuilder for ApplicationMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ApplicationMethods<'a, C, A> {} -impl<'a, C, NC, A> ApplicationMethods<'a, C, NC, A> { +impl<'a, C, A> ApplicationMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1121,7 +1117,7 @@ impl<'a, C, NC, A> ApplicationMethods<'a, C, NC, A> { /// # Arguments /// /// * `applicationId` - The application ID from the Google Play developer console. - pub fn list_hidden(&self, application_id: &str) -> ApplicationListHiddenCall<'a, C, NC, A> { + pub fn list_hidden(&self, application_id: &str) -> ApplicationListHiddenCall<'a, C, A> { ApplicationListHiddenCall { hub: self.hub, _application_id: application_id.to_string(), @@ -1164,20 +1160,20 @@ impl<'a, C, NC, A> ApplicationMethods<'a, C, NC, A> { /// let rb = hub.rooms(); /// # } /// ``` -pub struct RoomMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RoomMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, } -impl<'a, C, NC, A> MethodsBuilder for RoomMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for RoomMethods<'a, C, A> {} -impl<'a, C, NC, A> RoomMethods<'a, C, NC, A> { +impl<'a, C, A> RoomMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Deletes rooms where the only room participants are from whitelisted tester accounts for your application. This method is only available to user accounts for your developer console. - pub fn reset_for_all_players(&self) -> RoomResetForAllPlayerCall<'a, C, NC, A> { + pub fn reset_for_all_players(&self) -> RoomResetForAllPlayerCall<'a, C, A> { RoomResetForAllPlayerCall { hub: self.hub, _delegate: Default::default(), @@ -1189,7 +1185,7 @@ impl<'a, C, NC, A> RoomMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Reset all rooms for the currently authenticated player for your application. This method is only accessible to whitelisted tester accounts for your application. - pub fn reset(&self) -> RoomResetCall<'a, C, NC, A> { + pub fn reset(&self) -> RoomResetCall<'a, C, A> { RoomResetCall { hub: self.hub, _delegate: Default::default(), @@ -1229,20 +1225,20 @@ impl<'a, C, NC, A> RoomMethods<'a, C, NC, A> { /// let rb = hub.quests(); /// # } /// ``` -pub struct QuestMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct QuestMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, } -impl<'a, C, NC, A> MethodsBuilder for QuestMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for QuestMethods<'a, C, A> {} -impl<'a, C, NC, A> QuestMethods<'a, C, NC, A> { +impl<'a, C, A> QuestMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Resets all draft quests for all players. This method is only available to user accounts for your developer console. - pub fn reset_all_for_all_players(&self) -> QuestResetAllForAllPlayerCall<'a, C, NC, A> { + pub fn reset_all_for_all_players(&self) -> QuestResetAllForAllPlayerCall<'a, C, A> { QuestResetAllForAllPlayerCall { hub: self.hub, _delegate: Default::default(), @@ -1258,7 +1254,7 @@ impl<'a, C, NC, A> QuestMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn reset_multiple_for_all_players(&self, request: &QuestsResetMultipleForAllRequest) -> QuestResetMultipleForAllPlayerCall<'a, C, NC, A> { + pub fn reset_multiple_for_all_players(&self, request: &QuestsResetMultipleForAllRequest) -> QuestResetMultipleForAllPlayerCall<'a, C, A> { QuestResetMultipleForAllPlayerCall { hub: self.hub, _request: request.clone(), @@ -1271,7 +1267,7 @@ impl<'a, C, NC, A> QuestMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Resets all player progress on all quests for the currently authenticated player. This method is only accessible to whitelisted tester accounts for your application. - pub fn reset_all(&self) -> QuestResetAllCall<'a, C, NC, A> { + pub fn reset_all(&self) -> QuestResetAllCall<'a, C, A> { QuestResetAllCall { hub: self.hub, _delegate: Default::default(), @@ -1287,7 +1283,7 @@ impl<'a, C, NC, A> QuestMethods<'a, C, NC, A> { /// # Arguments /// /// * `questId` - The ID of the quest. - pub fn reset_for_all_players(&self, quest_id: &str) -> QuestResetForAllPlayerCall<'a, C, NC, A> { + pub fn reset_for_all_players(&self, quest_id: &str) -> QuestResetForAllPlayerCall<'a, C, A> { QuestResetForAllPlayerCall { hub: self.hub, _quest_id: quest_id.to_string(), @@ -1304,7 +1300,7 @@ impl<'a, C, NC, A> QuestMethods<'a, C, NC, A> { /// # Arguments /// /// * `questId` - The ID of the quest. - pub fn reset(&self, quest_id: &str) -> QuestResetCall<'a, C, NC, A> { + pub fn reset(&self, quest_id: &str) -> QuestResetCall<'a, C, A> { QuestResetCall { hub: self.hub, _quest_id: quest_id.to_string(), @@ -1345,20 +1341,20 @@ impl<'a, C, NC, A> QuestMethods<'a, C, NC, A> { /// let rb = hub.events(); /// # } /// ``` -pub struct EventMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, } -impl<'a, C, NC, A> MethodsBuilder for EventMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for EventMethods<'a, C, A> {} -impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { +impl<'a, C, A> EventMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Resets all draft events for all players. This method is only available to user accounts for your developer console. All quests that use any of these events will also be reset. - pub fn reset_all_for_all_players(&self) -> EventResetAllForAllPlayerCall<'a, C, NC, A> { + pub fn reset_all_for_all_players(&self) -> EventResetAllForAllPlayerCall<'a, C, A> { EventResetAllForAllPlayerCall { hub: self.hub, _delegate: Default::default(), @@ -1374,7 +1370,7 @@ impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { /// # Arguments /// /// * `eventId` - The ID of the event. - pub fn reset(&self, event_id: &str) -> EventResetCall<'a, C, NC, A> { + pub fn reset(&self, event_id: &str) -> EventResetCall<'a, C, A> { EventResetCall { hub: self.hub, _event_id: event_id.to_string(), @@ -1387,7 +1383,7 @@ impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Resets all player progress on all events for the currently authenticated player. This method is only accessible to whitelisted tester accounts for your application. All quests for this player will also be reset. - pub fn reset_all(&self) -> EventResetAllCall<'a, C, NC, A> { + pub fn reset_all(&self) -> EventResetAllCall<'a, C, A> { EventResetAllCall { hub: self.hub, _delegate: Default::default(), @@ -1403,7 +1399,7 @@ impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn reset_multiple_for_all_players(&self, request: &EventsResetMultipleForAllRequest) -> EventResetMultipleForAllPlayerCall<'a, C, NC, A> { + pub fn reset_multiple_for_all_players(&self, request: &EventsResetMultipleForAllRequest) -> EventResetMultipleForAllPlayerCall<'a, C, A> { EventResetMultipleForAllPlayerCall { hub: self.hub, _request: request.clone(), @@ -1420,7 +1416,7 @@ impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { /// # Arguments /// /// * `eventId` - The ID of the event. - pub fn reset_for_all_players(&self, event_id: &str) -> EventResetForAllPlayerCall<'a, C, NC, A> { + pub fn reset_for_all_players(&self, event_id: &str) -> EventResetForAllPlayerCall<'a, C, A> { EventResetForAllPlayerCall { hub: self.hub, _event_id: event_id.to_string(), @@ -1469,18 +1465,18 @@ impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct AchievementResetAllForAllPlayerCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AchievementResetAllForAllPlayerCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AchievementResetAllForAllPlayerCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AchievementResetAllForAllPlayerCall<'a, C, A> {} -impl<'a, C, NC, A> AchievementResetAllForAllPlayerCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AchievementResetAllForAllPlayerCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1577,7 +1573,7 @@ impl<'a, C, NC, A> AchievementResetAllForAllPlayerCall<'a, C, NC, A> where NC: h /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementResetAllForAllPlayerCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementResetAllForAllPlayerCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1598,7 +1594,7 @@ impl<'a, C, NC, A> AchievementResetAllForAllPlayerCall<'a, C, NC, A> where NC: h /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AchievementResetAllForAllPlayerCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AchievementResetAllForAllPlayerCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1615,7 +1611,7 @@ impl<'a, C, NC, A> AchievementResetAllForAllPlayerCall<'a, C, NC, A> where NC: h /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AchievementResetAllForAllPlayerCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AchievementResetAllForAllPlayerCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1653,19 +1649,19 @@ impl<'a, C, NC, A> AchievementResetAllForAllPlayerCall<'a, C, NC, A> where NC: h /// .doit(); /// # } /// ``` -pub struct AchievementResetForAllPlayerCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AchievementResetForAllPlayerCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _achievement_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AchievementResetForAllPlayerCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AchievementResetForAllPlayerCall<'a, C, A> {} -impl<'a, C, NC, A> AchievementResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AchievementResetForAllPlayerCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1786,7 +1782,7 @@ impl<'a, C, NC, A> AchievementResetForAllPlayerCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// The ID of the achievement used by this method. - pub fn achievement_id(mut self, new_value: &str) -> AchievementResetForAllPlayerCall<'a, C, NC, A> { + pub fn achievement_id(mut self, new_value: &str) -> AchievementResetForAllPlayerCall<'a, C, A> { self._achievement_id = new_value.to_string(); self } @@ -1797,7 +1793,7 @@ impl<'a, C, NC, A> AchievementResetForAllPlayerCall<'a, C, NC, A> where NC: hype /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementResetForAllPlayerCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementResetForAllPlayerCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1818,7 +1814,7 @@ impl<'a, C, NC, A> AchievementResetForAllPlayerCall<'a, C, NC, A> where NC: hype /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AchievementResetForAllPlayerCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AchievementResetForAllPlayerCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1835,7 +1831,7 @@ impl<'a, C, NC, A> AchievementResetForAllPlayerCall<'a, C, NC, A> where NC: hype /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AchievementResetForAllPlayerCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AchievementResetForAllPlayerCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1873,19 +1869,19 @@ impl<'a, C, NC, A> AchievementResetForAllPlayerCall<'a, C, NC, A> where NC: hype /// .doit(); /// # } /// ``` -pub struct AchievementResetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AchievementResetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _achievement_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AchievementResetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AchievementResetCall<'a, C, A> {} -impl<'a, C, NC, A> AchievementResetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AchievementResetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2017,7 +2013,7 @@ impl<'a, C, NC, A> AchievementResetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID of the achievement used by this method. - pub fn achievement_id(mut self, new_value: &str) -> AchievementResetCall<'a, C, NC, A> { + pub fn achievement_id(mut self, new_value: &str) -> AchievementResetCall<'a, C, A> { self._achievement_id = new_value.to_string(); self } @@ -2028,7 +2024,7 @@ impl<'a, C, NC, A> AchievementResetCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementResetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementResetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2049,7 +2045,7 @@ impl<'a, C, NC, A> AchievementResetCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AchievementResetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AchievementResetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2066,7 +2062,7 @@ impl<'a, C, NC, A> AchievementResetCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AchievementResetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AchievementResetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2110,19 +2106,19 @@ impl<'a, C, NC, A> AchievementResetCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct AchievementResetMultipleForAllPlayerCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AchievementResetMultipleForAllPlayerCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _request: AchievementResetMultipleForAllRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AchievementResetMultipleForAllPlayerCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AchievementResetMultipleForAllPlayerCall<'a, C, A> {} -impl<'a, C, NC, A> AchievementResetMultipleForAllPlayerCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AchievementResetMultipleForAllPlayerCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2225,7 +2221,7 @@ impl<'a, C, NC, A> AchievementResetMultipleForAllPlayerCall<'a, C, NC, A> where /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AchievementResetMultipleForAllRequest) -> AchievementResetMultipleForAllPlayerCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AchievementResetMultipleForAllRequest) -> AchievementResetMultipleForAllPlayerCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2236,7 +2232,7 @@ impl<'a, C, NC, A> AchievementResetMultipleForAllPlayerCall<'a, C, NC, A> where /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementResetMultipleForAllPlayerCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementResetMultipleForAllPlayerCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2257,7 +2253,7 @@ impl<'a, C, NC, A> AchievementResetMultipleForAllPlayerCall<'a, C, NC, A> where /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AchievementResetMultipleForAllPlayerCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AchievementResetMultipleForAllPlayerCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2274,7 +2270,7 @@ impl<'a, C, NC, A> AchievementResetMultipleForAllPlayerCall<'a, C, NC, A> where /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AchievementResetMultipleForAllPlayerCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AchievementResetMultipleForAllPlayerCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2312,18 +2308,18 @@ impl<'a, C, NC, A> AchievementResetMultipleForAllPlayerCall<'a, C, NC, A> where /// .doit(); /// # } /// ``` -pub struct AchievementResetAllCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AchievementResetAllCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AchievementResetAllCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AchievementResetAllCall<'a, C, A> {} -impl<'a, C, NC, A> AchievementResetAllCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AchievementResetAllCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2431,7 +2427,7 @@ impl<'a, C, NC, A> AchievementResetAllCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementResetAllCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AchievementResetAllCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2452,7 +2448,7 @@ impl<'a, C, NC, A> AchievementResetAllCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AchievementResetAllCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AchievementResetAllCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2469,7 +2465,7 @@ impl<'a, C, NC, A> AchievementResetAllCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AchievementResetAllCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AchievementResetAllCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2507,10 +2503,10 @@ impl<'a, C, NC, A> AchievementResetAllCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct PlayerHideCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlayerHideCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _application_id: String, _player_id: String, _delegate: Option<&'a mut Delegate>, @@ -2518,9 +2514,9 @@ pub struct PlayerHideCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlayerHideCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlayerHideCall<'a, C, A> {} -impl<'a, C, NC, A> PlayerHideCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlayerHideCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2642,7 +2638,7 @@ impl<'a, C, NC, A> PlayerHideCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The application ID from the Google Play developer console. - pub fn application_id(mut self, new_value: &str) -> PlayerHideCall<'a, C, NC, A> { + pub fn application_id(mut self, new_value: &str) -> PlayerHideCall<'a, C, A> { self._application_id = new_value.to_string(); self } @@ -2652,7 +2648,7 @@ impl<'a, C, NC, A> PlayerHideCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// A player ID. A value of me may be used in place of the authenticated player's ID. - pub fn player_id(mut self, new_value: &str) -> PlayerHideCall<'a, C, NC, A> { + pub fn player_id(mut self, new_value: &str) -> PlayerHideCall<'a, C, A> { self._player_id = new_value.to_string(); self } @@ -2663,7 +2659,7 @@ impl<'a, C, NC, A> PlayerHideCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlayerHideCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlayerHideCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2684,7 +2680,7 @@ impl<'a, C, NC, A> PlayerHideCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlayerHideCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlayerHideCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2701,7 +2697,7 @@ impl<'a, C, NC, A> PlayerHideCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlayerHideCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlayerHideCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2739,10 +2735,10 @@ impl<'a, C, NC, A> PlayerHideCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct PlayerUnhideCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlayerUnhideCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _application_id: String, _player_id: String, _delegate: Option<&'a mut Delegate>, @@ -2750,9 +2746,9 @@ pub struct PlayerUnhideCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlayerUnhideCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlayerUnhideCall<'a, C, A> {} -impl<'a, C, NC, A> PlayerUnhideCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlayerUnhideCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2874,7 +2870,7 @@ impl<'a, C, NC, A> PlayerUnhideCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The application ID from the Google Play developer console. - pub fn application_id(mut self, new_value: &str) -> PlayerUnhideCall<'a, C, NC, A> { + pub fn application_id(mut self, new_value: &str) -> PlayerUnhideCall<'a, C, A> { self._application_id = new_value.to_string(); self } @@ -2884,7 +2880,7 @@ impl<'a, C, NC, A> PlayerUnhideCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// A player ID. A value of me may be used in place of the authenticated player's ID. - pub fn player_id(mut self, new_value: &str) -> PlayerUnhideCall<'a, C, NC, A> { + pub fn player_id(mut self, new_value: &str) -> PlayerUnhideCall<'a, C, A> { self._player_id = new_value.to_string(); self } @@ -2895,7 +2891,7 @@ impl<'a, C, NC, A> PlayerUnhideCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlayerUnhideCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlayerUnhideCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2916,7 +2912,7 @@ impl<'a, C, NC, A> PlayerUnhideCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlayerUnhideCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlayerUnhideCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2933,7 +2929,7 @@ impl<'a, C, NC, A> PlayerUnhideCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlayerUnhideCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlayerUnhideCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2977,19 +2973,19 @@ impl<'a, C, NC, A> PlayerUnhideCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct ScoreResetMultipleForAllPlayerCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ScoreResetMultipleForAllPlayerCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _request: ScoresResetMultipleForAllRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ScoreResetMultipleForAllPlayerCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ScoreResetMultipleForAllPlayerCall<'a, C, A> {} -impl<'a, C, NC, A> ScoreResetMultipleForAllPlayerCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ScoreResetMultipleForAllPlayerCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3092,7 +3088,7 @@ impl<'a, C, NC, A> ScoreResetMultipleForAllPlayerCall<'a, C, NC, A> where NC: hy /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ScoresResetMultipleForAllRequest) -> ScoreResetMultipleForAllPlayerCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ScoresResetMultipleForAllRequest) -> ScoreResetMultipleForAllPlayerCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3103,7 +3099,7 @@ impl<'a, C, NC, A> ScoreResetMultipleForAllPlayerCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScoreResetMultipleForAllPlayerCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScoreResetMultipleForAllPlayerCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3124,7 +3120,7 @@ impl<'a, C, NC, A> ScoreResetMultipleForAllPlayerCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ScoreResetMultipleForAllPlayerCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ScoreResetMultipleForAllPlayerCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3141,7 +3137,7 @@ impl<'a, C, NC, A> ScoreResetMultipleForAllPlayerCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ScoreResetMultipleForAllPlayerCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ScoreResetMultipleForAllPlayerCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3179,18 +3175,18 @@ impl<'a, C, NC, A> ScoreResetMultipleForAllPlayerCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct ScoreResetAllForAllPlayerCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ScoreResetAllForAllPlayerCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ScoreResetAllForAllPlayerCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ScoreResetAllForAllPlayerCall<'a, C, A> {} -impl<'a, C, NC, A> ScoreResetAllForAllPlayerCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ScoreResetAllForAllPlayerCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3287,7 +3283,7 @@ impl<'a, C, NC, A> ScoreResetAllForAllPlayerCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScoreResetAllForAllPlayerCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScoreResetAllForAllPlayerCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3308,7 +3304,7 @@ impl<'a, C, NC, A> ScoreResetAllForAllPlayerCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ScoreResetAllForAllPlayerCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ScoreResetAllForAllPlayerCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3325,7 +3321,7 @@ impl<'a, C, NC, A> ScoreResetAllForAllPlayerCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ScoreResetAllForAllPlayerCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ScoreResetAllForAllPlayerCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3363,18 +3359,18 @@ impl<'a, C, NC, A> ScoreResetAllForAllPlayerCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct ScoreResetAllCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ScoreResetAllCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ScoreResetAllCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ScoreResetAllCall<'a, C, A> {} -impl<'a, C, NC, A> ScoreResetAllCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ScoreResetAllCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3482,7 +3478,7 @@ impl<'a, C, NC, A> ScoreResetAllCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScoreResetAllCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScoreResetAllCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3503,7 +3499,7 @@ impl<'a, C, NC, A> ScoreResetAllCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ScoreResetAllCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ScoreResetAllCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3520,7 +3516,7 @@ impl<'a, C, NC, A> ScoreResetAllCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ScoreResetAllCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ScoreResetAllCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3558,19 +3554,19 @@ impl<'a, C, NC, A> ScoreResetAllCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct ScoreResetForAllPlayerCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ScoreResetForAllPlayerCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _leaderboard_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ScoreResetForAllPlayerCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ScoreResetForAllPlayerCall<'a, C, A> {} -impl<'a, C, NC, A> ScoreResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ScoreResetForAllPlayerCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3691,7 +3687,7 @@ impl<'a, C, NC, A> ScoreResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The ID of the leaderboard. - pub fn leaderboard_id(mut self, new_value: &str) -> ScoreResetForAllPlayerCall<'a, C, NC, A> { + pub fn leaderboard_id(mut self, new_value: &str) -> ScoreResetForAllPlayerCall<'a, C, A> { self._leaderboard_id = new_value.to_string(); self } @@ -3702,7 +3698,7 @@ impl<'a, C, NC, A> ScoreResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScoreResetForAllPlayerCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScoreResetForAllPlayerCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3723,7 +3719,7 @@ impl<'a, C, NC, A> ScoreResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ScoreResetForAllPlayerCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ScoreResetForAllPlayerCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3740,7 +3736,7 @@ impl<'a, C, NC, A> ScoreResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ScoreResetForAllPlayerCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ScoreResetForAllPlayerCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3778,19 +3774,19 @@ impl<'a, C, NC, A> ScoreResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct ScoreResetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ScoreResetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _leaderboard_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ScoreResetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ScoreResetCall<'a, C, A> {} -impl<'a, C, NC, A> ScoreResetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ScoreResetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3922,7 +3918,7 @@ impl<'a, C, NC, A> ScoreResetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the leaderboard. - pub fn leaderboard_id(mut self, new_value: &str) -> ScoreResetCall<'a, C, NC, A> { + pub fn leaderboard_id(mut self, new_value: &str) -> ScoreResetCall<'a, C, A> { self._leaderboard_id = new_value.to_string(); self } @@ -3933,7 +3929,7 @@ impl<'a, C, NC, A> ScoreResetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScoreResetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ScoreResetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3954,7 +3950,7 @@ impl<'a, C, NC, A> ScoreResetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ScoreResetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ScoreResetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3971,7 +3967,7 @@ impl<'a, C, NC, A> ScoreResetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ScoreResetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ScoreResetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4009,18 +4005,18 @@ impl<'a, C, NC, A> ScoreResetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct TurnBasedMatcheResetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TurnBasedMatcheResetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TurnBasedMatcheResetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TurnBasedMatcheResetCall<'a, C, A> {} -impl<'a, C, NC, A> TurnBasedMatcheResetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TurnBasedMatcheResetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4117,7 +4113,7 @@ impl<'a, C, NC, A> TurnBasedMatcheResetCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheResetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheResetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4138,7 +4134,7 @@ impl<'a, C, NC, A> TurnBasedMatcheResetCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheResetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheResetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4155,7 +4151,7 @@ impl<'a, C, NC, A> TurnBasedMatcheResetCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheResetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheResetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4193,18 +4189,18 @@ impl<'a, C, NC, A> TurnBasedMatcheResetCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct TurnBasedMatcheResetForAllPlayerCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TurnBasedMatcheResetForAllPlayerCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TurnBasedMatcheResetForAllPlayerCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TurnBasedMatcheResetForAllPlayerCall<'a, C, A> {} -impl<'a, C, NC, A> TurnBasedMatcheResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TurnBasedMatcheResetForAllPlayerCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4301,7 +4297,7 @@ impl<'a, C, NC, A> TurnBasedMatcheResetForAllPlayerCall<'a, C, NC, A> where NC: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheResetForAllPlayerCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TurnBasedMatcheResetForAllPlayerCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4322,7 +4318,7 @@ impl<'a, C, NC, A> TurnBasedMatcheResetForAllPlayerCall<'a, C, NC, A> where NC: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheResetForAllPlayerCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TurnBasedMatcheResetForAllPlayerCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4339,7 +4335,7 @@ impl<'a, C, NC, A> TurnBasedMatcheResetForAllPlayerCall<'a, C, NC, A> where NC: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheResetForAllPlayerCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TurnBasedMatcheResetForAllPlayerCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4379,10 +4375,10 @@ impl<'a, C, NC, A> TurnBasedMatcheResetForAllPlayerCall<'a, C, NC, A> where NC: /// .doit(); /// # } /// ``` -pub struct ApplicationListHiddenCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ApplicationListHiddenCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _application_id: String, _page_token: Option, _max_results: Option, @@ -4391,9 +4387,9 @@ pub struct ApplicationListHiddenCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ApplicationListHiddenCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ApplicationListHiddenCall<'a, C, A> {} -impl<'a, C, NC, A> ApplicationListHiddenCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ApplicationListHiddenCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4531,7 +4527,7 @@ impl<'a, C, NC, A> ApplicationListHiddenCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The application ID from the Google Play developer console. - pub fn application_id(mut self, new_value: &str) -> ApplicationListHiddenCall<'a, C, NC, A> { + pub fn application_id(mut self, new_value: &str) -> ApplicationListHiddenCall<'a, C, A> { self._application_id = new_value.to_string(); self } @@ -4539,7 +4535,7 @@ impl<'a, C, NC, A> ApplicationListHiddenCall<'a, C, NC, A> where NC: hyper::net: /// /// /// The token returned by the previous request. - pub fn page_token(mut self, new_value: &str) -> ApplicationListHiddenCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ApplicationListHiddenCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -4547,7 +4543,7 @@ impl<'a, C, NC, A> ApplicationListHiddenCall<'a, C, NC, A> where NC: hyper::net: /// /// /// The maximum number of player resources to return in the response, used for paging. For any response, the actual number of player resources returned may be less than the specified maxResults. - pub fn max_results(mut self, new_value: i32) -> ApplicationListHiddenCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ApplicationListHiddenCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -4558,7 +4554,7 @@ impl<'a, C, NC, A> ApplicationListHiddenCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ApplicationListHiddenCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ApplicationListHiddenCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4579,7 +4575,7 @@ impl<'a, C, NC, A> ApplicationListHiddenCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ApplicationListHiddenCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ApplicationListHiddenCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4596,7 +4592,7 @@ impl<'a, C, NC, A> ApplicationListHiddenCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ApplicationListHiddenCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ApplicationListHiddenCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4634,18 +4630,18 @@ impl<'a, C, NC, A> ApplicationListHiddenCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct RoomResetForAllPlayerCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RoomResetForAllPlayerCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RoomResetForAllPlayerCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RoomResetForAllPlayerCall<'a, C, A> {} -impl<'a, C, NC, A> RoomResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RoomResetForAllPlayerCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4742,7 +4738,7 @@ impl<'a, C, NC, A> RoomResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RoomResetForAllPlayerCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RoomResetForAllPlayerCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4763,7 +4759,7 @@ impl<'a, C, NC, A> RoomResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RoomResetForAllPlayerCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RoomResetForAllPlayerCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4780,7 +4776,7 @@ impl<'a, C, NC, A> RoomResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RoomResetForAllPlayerCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RoomResetForAllPlayerCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4818,18 +4814,18 @@ impl<'a, C, NC, A> RoomResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct RoomResetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RoomResetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RoomResetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RoomResetCall<'a, C, A> {} -impl<'a, C, NC, A> RoomResetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RoomResetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4926,7 +4922,7 @@ impl<'a, C, NC, A> RoomResetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RoomResetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RoomResetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4947,7 +4943,7 @@ impl<'a, C, NC, A> RoomResetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RoomResetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RoomResetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4964,7 +4960,7 @@ impl<'a, C, NC, A> RoomResetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RoomResetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RoomResetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5002,18 +4998,18 @@ impl<'a, C, NC, A> RoomResetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct QuestResetAllForAllPlayerCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct QuestResetAllForAllPlayerCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for QuestResetAllForAllPlayerCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for QuestResetAllForAllPlayerCall<'a, C, A> {} -impl<'a, C, NC, A> QuestResetAllForAllPlayerCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> QuestResetAllForAllPlayerCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5110,7 +5106,7 @@ impl<'a, C, NC, A> QuestResetAllForAllPlayerCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> QuestResetAllForAllPlayerCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> QuestResetAllForAllPlayerCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5131,7 +5127,7 @@ impl<'a, C, NC, A> QuestResetAllForAllPlayerCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> QuestResetAllForAllPlayerCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> QuestResetAllForAllPlayerCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5148,7 +5144,7 @@ impl<'a, C, NC, A> QuestResetAllForAllPlayerCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> QuestResetAllForAllPlayerCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> QuestResetAllForAllPlayerCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5192,19 +5188,19 @@ impl<'a, C, NC, A> QuestResetAllForAllPlayerCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct QuestResetMultipleForAllPlayerCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct QuestResetMultipleForAllPlayerCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _request: QuestsResetMultipleForAllRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for QuestResetMultipleForAllPlayerCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for QuestResetMultipleForAllPlayerCall<'a, C, A> {} -impl<'a, C, NC, A> QuestResetMultipleForAllPlayerCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> QuestResetMultipleForAllPlayerCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5307,7 +5303,7 @@ impl<'a, C, NC, A> QuestResetMultipleForAllPlayerCall<'a, C, NC, A> where NC: hy /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &QuestsResetMultipleForAllRequest) -> QuestResetMultipleForAllPlayerCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &QuestsResetMultipleForAllRequest) -> QuestResetMultipleForAllPlayerCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5318,7 +5314,7 @@ impl<'a, C, NC, A> QuestResetMultipleForAllPlayerCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> QuestResetMultipleForAllPlayerCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> QuestResetMultipleForAllPlayerCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5339,7 +5335,7 @@ impl<'a, C, NC, A> QuestResetMultipleForAllPlayerCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> QuestResetMultipleForAllPlayerCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> QuestResetMultipleForAllPlayerCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5356,7 +5352,7 @@ impl<'a, C, NC, A> QuestResetMultipleForAllPlayerCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> QuestResetMultipleForAllPlayerCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> QuestResetMultipleForAllPlayerCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5394,18 +5390,18 @@ impl<'a, C, NC, A> QuestResetMultipleForAllPlayerCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct QuestResetAllCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct QuestResetAllCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for QuestResetAllCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for QuestResetAllCall<'a, C, A> {} -impl<'a, C, NC, A> QuestResetAllCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> QuestResetAllCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5502,7 +5498,7 @@ impl<'a, C, NC, A> QuestResetAllCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> QuestResetAllCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> QuestResetAllCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5523,7 +5519,7 @@ impl<'a, C, NC, A> QuestResetAllCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> QuestResetAllCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> QuestResetAllCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5540,7 +5536,7 @@ impl<'a, C, NC, A> QuestResetAllCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> QuestResetAllCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> QuestResetAllCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5578,19 +5574,19 @@ impl<'a, C, NC, A> QuestResetAllCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct QuestResetForAllPlayerCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct QuestResetForAllPlayerCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _quest_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for QuestResetForAllPlayerCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for QuestResetForAllPlayerCall<'a, C, A> {} -impl<'a, C, NC, A> QuestResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> QuestResetForAllPlayerCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5711,7 +5707,7 @@ impl<'a, C, NC, A> QuestResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The ID of the quest. - pub fn quest_id(mut self, new_value: &str) -> QuestResetForAllPlayerCall<'a, C, NC, A> { + pub fn quest_id(mut self, new_value: &str) -> QuestResetForAllPlayerCall<'a, C, A> { self._quest_id = new_value.to_string(); self } @@ -5722,7 +5718,7 @@ impl<'a, C, NC, A> QuestResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> QuestResetForAllPlayerCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> QuestResetForAllPlayerCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5743,7 +5739,7 @@ impl<'a, C, NC, A> QuestResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> QuestResetForAllPlayerCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> QuestResetForAllPlayerCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5760,7 +5756,7 @@ impl<'a, C, NC, A> QuestResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> QuestResetForAllPlayerCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> QuestResetForAllPlayerCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5798,19 +5794,19 @@ impl<'a, C, NC, A> QuestResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct QuestResetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct QuestResetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _quest_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for QuestResetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for QuestResetCall<'a, C, A> {} -impl<'a, C, NC, A> QuestResetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> QuestResetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5931,7 +5927,7 @@ impl<'a, C, NC, A> QuestResetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the quest. - pub fn quest_id(mut self, new_value: &str) -> QuestResetCall<'a, C, NC, A> { + pub fn quest_id(mut self, new_value: &str) -> QuestResetCall<'a, C, A> { self._quest_id = new_value.to_string(); self } @@ -5942,7 +5938,7 @@ impl<'a, C, NC, A> QuestResetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> QuestResetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> QuestResetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5963,7 +5959,7 @@ impl<'a, C, NC, A> QuestResetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> QuestResetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> QuestResetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5980,7 +5976,7 @@ impl<'a, C, NC, A> QuestResetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> QuestResetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> QuestResetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6018,18 +6014,18 @@ impl<'a, C, NC, A> QuestResetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct EventResetAllForAllPlayerCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventResetAllForAllPlayerCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventResetAllForAllPlayerCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventResetAllForAllPlayerCall<'a, C, A> {} -impl<'a, C, NC, A> EventResetAllForAllPlayerCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventResetAllForAllPlayerCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6126,7 +6122,7 @@ impl<'a, C, NC, A> EventResetAllForAllPlayerCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventResetAllForAllPlayerCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventResetAllForAllPlayerCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6147,7 +6143,7 @@ impl<'a, C, NC, A> EventResetAllForAllPlayerCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventResetAllForAllPlayerCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventResetAllForAllPlayerCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6164,7 +6160,7 @@ impl<'a, C, NC, A> EventResetAllForAllPlayerCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventResetAllForAllPlayerCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventResetAllForAllPlayerCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6202,19 +6198,19 @@ impl<'a, C, NC, A> EventResetAllForAllPlayerCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct EventResetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventResetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _event_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventResetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventResetCall<'a, C, A> {} -impl<'a, C, NC, A> EventResetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventResetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6335,7 +6331,7 @@ impl<'a, C, NC, A> EventResetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the event. - pub fn event_id(mut self, new_value: &str) -> EventResetCall<'a, C, NC, A> { + pub fn event_id(mut self, new_value: &str) -> EventResetCall<'a, C, A> { self._event_id = new_value.to_string(); self } @@ -6346,7 +6342,7 @@ impl<'a, C, NC, A> EventResetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventResetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventResetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6367,7 +6363,7 @@ impl<'a, C, NC, A> EventResetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventResetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventResetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6384,7 +6380,7 @@ impl<'a, C, NC, A> EventResetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventResetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventResetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6422,18 +6418,18 @@ impl<'a, C, NC, A> EventResetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct EventResetAllCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventResetAllCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventResetAllCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventResetAllCall<'a, C, A> {} -impl<'a, C, NC, A> EventResetAllCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventResetAllCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6530,7 +6526,7 @@ impl<'a, C, NC, A> EventResetAllCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventResetAllCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventResetAllCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6551,7 +6547,7 @@ impl<'a, C, NC, A> EventResetAllCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventResetAllCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventResetAllCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6568,7 +6564,7 @@ impl<'a, C, NC, A> EventResetAllCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventResetAllCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventResetAllCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6612,19 +6608,19 @@ impl<'a, C, NC, A> EventResetAllCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct EventResetMultipleForAllPlayerCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventResetMultipleForAllPlayerCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _request: EventsResetMultipleForAllRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventResetMultipleForAllPlayerCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventResetMultipleForAllPlayerCall<'a, C, A> {} -impl<'a, C, NC, A> EventResetMultipleForAllPlayerCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventResetMultipleForAllPlayerCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6727,7 +6723,7 @@ impl<'a, C, NC, A> EventResetMultipleForAllPlayerCall<'a, C, NC, A> where NC: hy /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &EventsResetMultipleForAllRequest) -> EventResetMultipleForAllPlayerCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &EventsResetMultipleForAllRequest) -> EventResetMultipleForAllPlayerCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6738,7 +6734,7 @@ impl<'a, C, NC, A> EventResetMultipleForAllPlayerCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventResetMultipleForAllPlayerCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventResetMultipleForAllPlayerCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6759,7 +6755,7 @@ impl<'a, C, NC, A> EventResetMultipleForAllPlayerCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventResetMultipleForAllPlayerCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventResetMultipleForAllPlayerCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6776,7 +6772,7 @@ impl<'a, C, NC, A> EventResetMultipleForAllPlayerCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventResetMultipleForAllPlayerCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventResetMultipleForAllPlayerCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6814,19 +6810,19 @@ impl<'a, C, NC, A> EventResetMultipleForAllPlayerCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct EventResetForAllPlayerCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventResetForAllPlayerCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GamesManagement, + hub: &'a GamesManagement, _event_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for EventResetForAllPlayerCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventResetForAllPlayerCall<'a, C, A> {} -impl<'a, C, NC, A> EventResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventResetForAllPlayerCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6947,7 +6943,7 @@ impl<'a, C, NC, A> EventResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The ID of the event. - pub fn event_id(mut self, new_value: &str) -> EventResetForAllPlayerCall<'a, C, NC, A> { + pub fn event_id(mut self, new_value: &str) -> EventResetForAllPlayerCall<'a, C, A> { self._event_id = new_value.to_string(); self } @@ -6958,7 +6954,7 @@ impl<'a, C, NC, A> EventResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventResetForAllPlayerCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventResetForAllPlayerCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6979,7 +6975,7 @@ impl<'a, C, NC, A> EventResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventResetForAllPlayerCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventResetForAllPlayerCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6996,7 +6992,7 @@ impl<'a, C, NC, A> EventResetForAllPlayerCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> EventResetForAllPlayerCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> EventResetForAllPlayerCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/gan1_beta1/Cargo.toml b/gen/gan1_beta1/Cargo.toml index 4c633c8c658..9efcf5901cc 100644 --- a/gen/gan1_beta1/Cargo.toml +++ b/gen/gan1_beta1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-gan1_beta1" -version = "0.1.4+20130205" +version = "0.1.5+20130205" authors = ["Sebastian Thiel "] description = "A complete library to interact with gan (protocol v1beta1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/gan1_beta1" homepage = "https://developers.google.com/affiliate-network/" -documentation = "http://byron.github.io/google-apis-rs/google-gan1_beta1" +documentation = "http://byron.github.io/google-apis-rs/google_gan1_beta1" license = "MIT" keywords = ["gan", "google", "protocol", "web", "api"] diff --git a/gen/gan1_beta1/README.md b/gen/gan1_beta1/README.md index c942f08e804..5d1df09d5c0 100644 --- a/gen/gan1_beta1/README.md +++ b/gen/gan1_beta1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-gan1_beta1` library allows access to all features of the *Google gan* service. -This documentation was generated from *gan* crate version *0.1.4+20130205*, where *20130205* is the exact revision of the *gan:v1beta1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *gan* crate version *0.1.5+20130205*, where *20130205* is the exact revision of the *gan:v1beta1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *gan* *v1_beta1* API can be found at the [official documentation site](https://developers.google.com/affiliate-network/). diff --git a/gen/gan1_beta1/src/cmn.rs b/gen/gan1_beta1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/gan1_beta1/src/cmn.rs +++ b/gen/gan1_beta1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/gan1_beta1/src/lib.rs b/gen/gan1_beta1/src/lib.rs index f5075bd50f3..16c110aba44 100644 --- a/gen/gan1_beta1/src/lib.rs +++ b/gen/gan1_beta1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *gan* crate version *0.1.4+20130205*, where *20130205* is the exact revision of the *gan:v1beta1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *gan* crate version *0.1.5+20130205*, where *20130205* is the exact revision of the *gan:v1beta1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *gan* *v1_beta1* API can be found at the //! [official documentation site](https://developers.google.com/affiliate-network/). @@ -213,7 +213,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -295,49 +294,46 @@ pub use cmn::{MultiPartReader, ToParts, MethodInfo, Result, Error, CallBuilder, /// } /// # } /// ``` -pub struct Gan { +pub struct Gan { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Gan {} +impl<'a, C, A> Hub for Gan {} -impl<'a, C, NC, A> Gan - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Gan + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Gan { + pub fn new(client: C, authenticator: A) -> Gan { Gan { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn advertisers(&'a self) -> AdvertiserMethods<'a, C, NC, A> { + pub fn advertisers(&'a self) -> AdvertiserMethods<'a, C, A> { AdvertiserMethods { hub: &self } } - pub fn cc_offers(&'a self) -> CcOfferMethods<'a, C, NC, A> { + pub fn cc_offers(&'a self) -> CcOfferMethods<'a, C, A> { CcOfferMethods { hub: &self } } - pub fn events(&'a self) -> EventMethods<'a, C, NC, A> { + pub fn events(&'a self) -> EventMethods<'a, C, A> { EventMethods { hub: &self } } - pub fn links(&'a self) -> LinkMethods<'a, C, NC, A> { + pub fn links(&'a self) -> LinkMethods<'a, C, A> { LinkMethods { hub: &self } } - pub fn publishers(&'a self) -> PublisherMethods<'a, C, NC, A> { + pub fn publishers(&'a self) -> PublisherMethods<'a, C, A> { PublisherMethods { hub: &self } } - pub fn reports(&'a self) -> ReportMethods<'a, C, NC, A> { + pub fn reports(&'a self) -> ReportMethods<'a, C, A> { ReportMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -1145,15 +1141,15 @@ impl Resource for CcOffer {} /// let rb = hub.publishers(); /// # } /// ``` -pub struct PublisherMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PublisherMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gan, + hub: &'a Gan, } -impl<'a, C, NC, A> MethodsBuilder for PublisherMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PublisherMethods<'a, C, A> {} -impl<'a, C, NC, A> PublisherMethods<'a, C, NC, A> { +impl<'a, C, A> PublisherMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1163,7 +1159,7 @@ impl<'a, C, NC, A> PublisherMethods<'a, C, NC, A> { /// /// * `role` - The role of the requester. Valid values: 'advertisers' or 'publishers'. /// * `roleId` - The ID of the requesting advertiser or publisher. - pub fn list(&self, role: &str, role_id: &str) -> PublisherListCall<'a, C, NC, A> { + pub fn list(&self, role: &str, role_id: &str) -> PublisherListCall<'a, C, A> { PublisherListCall { hub: self.hub, _role: role.to_string(), @@ -1188,7 +1184,7 @@ impl<'a, C, NC, A> PublisherMethods<'a, C, NC, A> { /// /// * `role` - The role of the requester. Valid values: 'advertisers' or 'publishers'. /// * `roleId` - The ID of the requesting advertiser or publisher. - pub fn get(&self, role: &str, role_id: &str) -> PublisherGetCall<'a, C, NC, A> { + pub fn get(&self, role: &str, role_id: &str) -> PublisherGetCall<'a, C, A> { PublisherGetCall { hub: self.hub, _role: role.to_string(), @@ -1230,15 +1226,15 @@ impl<'a, C, NC, A> PublisherMethods<'a, C, NC, A> { /// let rb = hub.links(); /// # } /// ``` -pub struct LinkMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LinkMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gan, + hub: &'a Gan, } -impl<'a, C, NC, A> MethodsBuilder for LinkMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for LinkMethods<'a, C, A> {} -impl<'a, C, NC, A> LinkMethods<'a, C, NC, A> { +impl<'a, C, A> LinkMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1249,7 +1245,7 @@ impl<'a, C, NC, A> LinkMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `role` - The role of the requester. Valid values: 'advertisers' or 'publishers'. /// * `roleId` - The ID of the requesting advertiser or publisher. - pub fn insert(&self, request: &Link, role: &str, role_id: &str) -> LinkInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Link, role: &str, role_id: &str) -> LinkInsertCall<'a, C, A> { LinkInsertCall { hub: self.hub, _request: request.clone(), @@ -1269,7 +1265,7 @@ impl<'a, C, NC, A> LinkMethods<'a, C, NC, A> { /// * `role` - The role of the requester. Valid values: 'advertisers' or 'publishers'. /// * `roleId` - The ID of the requesting advertiser or publisher. /// * `linkId` - The ID of the link to look up. - pub fn get(&self, role: &str, role_id: &str, link_id: &str) -> LinkGetCall<'a, C, NC, A> { + pub fn get(&self, role: &str, role_id: &str, link_id: &str) -> LinkGetCall<'a, C, A> { LinkGetCall { hub: self.hub, _role: role.to_string(), @@ -1288,7 +1284,7 @@ impl<'a, C, NC, A> LinkMethods<'a, C, NC, A> { /// /// * `role` - The role of the requester. Valid values: 'advertisers' or 'publishers'. /// * `roleId` - The ID of the requesting advertiser or publisher. - pub fn list(&self, role: &str, role_id: &str) -> LinkListCall<'a, C, NC, A> { + pub fn list(&self, role: &str, role_id: &str) -> LinkListCall<'a, C, A> { LinkListCall { hub: self.hub, _role: role.to_string(), @@ -1342,15 +1338,15 @@ impl<'a, C, NC, A> LinkMethods<'a, C, NC, A> { /// let rb = hub.reports(); /// # } /// ``` -pub struct ReportMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gan, + hub: &'a Gan, } -impl<'a, C, NC, A> MethodsBuilder for ReportMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ReportMethods<'a, C, A> {} -impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { +impl<'a, C, A> ReportMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1361,7 +1357,7 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// * `role` - The role of the requester. Valid values: 'advertisers' or 'publishers'. /// * `roleId` - The ID of the requesting advertiser or publisher. /// * `reportType` - The type of report being requested. Valid values: 'order_delta'. Required. - pub fn get(&self, role: &str, role_id: &str, report_type: &str) -> ReportGetCall<'a, C, NC, A> { + pub fn get(&self, role: &str, role_id: &str, report_type: &str) -> ReportGetCall<'a, C, A> { ReportGetCall { hub: self.hub, _role: role.to_string(), @@ -1414,15 +1410,15 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// let rb = hub.cc_offers(); /// # } /// ``` -pub struct CcOfferMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CcOfferMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gan, + hub: &'a Gan, } -impl<'a, C, NC, A> MethodsBuilder for CcOfferMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CcOfferMethods<'a, C, A> {} -impl<'a, C, NC, A> CcOfferMethods<'a, C, NC, A> { +impl<'a, C, A> CcOfferMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1431,7 +1427,7 @@ impl<'a, C, NC, A> CcOfferMethods<'a, C, NC, A> { /// # Arguments /// /// * `publisher` - The ID of the publisher in question. - pub fn list(&self, publisher: &str) -> CcOfferListCall<'a, C, NC, A> { + pub fn list(&self, publisher: &str) -> CcOfferListCall<'a, C, A> { CcOfferListCall { hub: self.hub, _publisher: publisher.to_string(), @@ -1473,15 +1469,15 @@ impl<'a, C, NC, A> CcOfferMethods<'a, C, NC, A> { /// let rb = hub.advertisers(); /// # } /// ``` -pub struct AdvertiserMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdvertiserMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gan, + hub: &'a Gan, } -impl<'a, C, NC, A> MethodsBuilder for AdvertiserMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AdvertiserMethods<'a, C, A> {} -impl<'a, C, NC, A> AdvertiserMethods<'a, C, NC, A> { +impl<'a, C, A> AdvertiserMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1491,7 +1487,7 @@ impl<'a, C, NC, A> AdvertiserMethods<'a, C, NC, A> { /// /// * `role` - The role of the requester. Valid values: 'advertisers' or 'publishers'. /// * `roleId` - The ID of the requesting advertiser or publisher. - pub fn get(&self, role: &str, role_id: &str) -> AdvertiserGetCall<'a, C, NC, A> { + pub fn get(&self, role: &str, role_id: &str) -> AdvertiserGetCall<'a, C, A> { AdvertiserGetCall { hub: self.hub, _role: role.to_string(), @@ -1510,7 +1506,7 @@ impl<'a, C, NC, A> AdvertiserMethods<'a, C, NC, A> { /// /// * `role` - The role of the requester. Valid values: 'advertisers' or 'publishers'. /// * `roleId` - The ID of the requesting advertiser or publisher. - pub fn list(&self, role: &str, role_id: &str) -> AdvertiserListCall<'a, C, NC, A> { + pub fn list(&self, role: &str, role_id: &str) -> AdvertiserListCall<'a, C, A> { AdvertiserListCall { hub: self.hub, _role: role.to_string(), @@ -1558,15 +1554,15 @@ impl<'a, C, NC, A> AdvertiserMethods<'a, C, NC, A> { /// let rb = hub.events(); /// # } /// ``` -pub struct EventMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gan, + hub: &'a Gan, } -impl<'a, C, NC, A> MethodsBuilder for EventMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for EventMethods<'a, C, A> {} -impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { +impl<'a, C, A> EventMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1576,7 +1572,7 @@ impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { /// /// * `role` - The role of the requester. Valid values: 'advertisers' or 'publishers'. /// * `roleId` - The ID of the requesting advertiser or publisher. - pub fn list(&self, role: &str, role_id: &str) -> EventListCall<'a, C, NC, A> { + pub fn list(&self, role: &str, role_id: &str) -> EventListCall<'a, C, A> { EventListCall { hub: self.hub, _role: role.to_string(), @@ -1648,10 +1644,10 @@ impl<'a, C, NC, A> EventMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct PublisherListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PublisherListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gan, + hub: &'a Gan, _role: String, _role_id: String, _relationship_status: Option, @@ -1665,9 +1661,9 @@ pub struct PublisherListCall<'a, C, NC, A> _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for PublisherListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PublisherListCall<'a, C, A> {} -impl<'a, C, NC, A> PublisherListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PublisherListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1819,7 +1815,7 @@ impl<'a, C, NC, A> PublisherListCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The role of the requester. Valid values: 'advertisers' or 'publishers'. - pub fn role(mut self, new_value: &str) -> PublisherListCall<'a, C, NC, A> { + pub fn role(mut self, new_value: &str) -> PublisherListCall<'a, C, A> { self._role = new_value.to_string(); self } @@ -1829,7 +1825,7 @@ impl<'a, C, NC, A> PublisherListCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the requesting advertiser or publisher. - pub fn role_id(mut self, new_value: &str) -> PublisherListCall<'a, C, NC, A> { + pub fn role_id(mut self, new_value: &str) -> PublisherListCall<'a, C, A> { self._role_id = new_value.to_string(); self } @@ -1837,7 +1833,7 @@ impl<'a, C, NC, A> PublisherListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Filters out all publishers for which do not have the given relationship status with the requesting publisher. - pub fn relationship_status(mut self, new_value: &str) -> PublisherListCall<'a, C, NC, A> { + pub fn relationship_status(mut self, new_value: &str) -> PublisherListCall<'a, C, A> { self._relationship_status = Some(new_value.to_string()); self } @@ -1845,7 +1841,7 @@ impl<'a, C, NC, A> PublisherListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Caret(^) delimted list of publisher categories. Valid categories: (unclassified|community_and_content|shopping_and_promotion|loyalty_and_rewards|network|search_specialist|comparison_shopping|email). Filters out all publishers not in one of the given advertiser categories. Optional. - pub fn publisher_category(mut self, new_value: &str) -> PublisherListCall<'a, C, NC, A> { + pub fn publisher_category(mut self, new_value: &str) -> PublisherListCall<'a, C, A> { self._publisher_category = Some(new_value.to_string()); self } @@ -1853,7 +1849,7 @@ impl<'a, C, NC, A> PublisherListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// The value of 'nextPageToken' from the previous page. Optional. - pub fn page_token(mut self, new_value: &str) -> PublisherListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> PublisherListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -1861,7 +1857,7 @@ impl<'a, C, NC, A> PublisherListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Filters out all publishers that have a seven day EPC average lower than the given value (inclusive). Min value 0.0. Optional. - pub fn min_seven_day_epc(mut self, new_value: f64) -> PublisherListCall<'a, C, NC, A> { + pub fn min_seven_day_epc(mut self, new_value: f64) -> PublisherListCall<'a, C, A> { self._min_seven_day_epc = Some(new_value); self } @@ -1869,7 +1865,7 @@ impl<'a, C, NC, A> PublisherListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// A value between 1 and 4, where 1 represents the quartile of publishers with the lowest ranks and 4 represents the quartile of publishers with the highest ranks. Filters out all publishers with a lower rank than the given quartile. For example if a 2 was given only publishers with a payout rank of 25 or higher would be included. Optional. - pub fn min_payout_rank(mut self, new_value: i32) -> PublisherListCall<'a, C, NC, A> { + pub fn min_payout_rank(mut self, new_value: i32) -> PublisherListCall<'a, C, A> { self._min_payout_rank = Some(new_value); self } @@ -1877,7 +1873,7 @@ impl<'a, C, NC, A> PublisherListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Filters out all publishers that have a ninety day EPC average lower than the given value (inclusive). Min value: 0.0. Optional. - pub fn min_ninety_day_epc(mut self, new_value: f64) -> PublisherListCall<'a, C, NC, A> { + pub fn min_ninety_day_epc(mut self, new_value: f64) -> PublisherListCall<'a, C, A> { self._min_ninety_day_epc = Some(new_value); self } @@ -1885,7 +1881,7 @@ impl<'a, C, NC, A> PublisherListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Max number of items to return in this page. Optional. Defaults to 20. - pub fn max_results(mut self, new_value: u32) -> PublisherListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> PublisherListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -1896,7 +1892,7 @@ impl<'a, C, NC, A> PublisherListCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PublisherListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PublisherListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1917,7 +1913,7 @@ impl<'a, C, NC, A> PublisherListCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PublisherListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PublisherListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1957,10 +1953,10 @@ impl<'a, C, NC, A> PublisherListCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct PublisherGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PublisherGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gan, + hub: &'a Gan, _role: String, _role_id: String, _publisher_id: Option, @@ -1968,9 +1964,9 @@ pub struct PublisherGetCall<'a, C, NC, A> _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for PublisherGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PublisherGetCall<'a, C, A> {} -impl<'a, C, NC, A> PublisherGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PublisherGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2104,7 +2100,7 @@ impl<'a, C, NC, A> PublisherGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The role of the requester. Valid values: 'advertisers' or 'publishers'. - pub fn role(mut self, new_value: &str) -> PublisherGetCall<'a, C, NC, A> { + pub fn role(mut self, new_value: &str) -> PublisherGetCall<'a, C, A> { self._role = new_value.to_string(); self } @@ -2114,7 +2110,7 @@ impl<'a, C, NC, A> PublisherGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the requesting advertiser or publisher. - pub fn role_id(mut self, new_value: &str) -> PublisherGetCall<'a, C, NC, A> { + pub fn role_id(mut self, new_value: &str) -> PublisherGetCall<'a, C, A> { self._role_id = new_value.to_string(); self } @@ -2122,7 +2118,7 @@ impl<'a, C, NC, A> PublisherGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The ID of the publisher to look up. Optional. - pub fn publisher_id(mut self, new_value: &str) -> PublisherGetCall<'a, C, NC, A> { + pub fn publisher_id(mut self, new_value: &str) -> PublisherGetCall<'a, C, A> { self._publisher_id = Some(new_value.to_string()); self } @@ -2133,7 +2129,7 @@ impl<'a, C, NC, A> PublisherGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PublisherGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PublisherGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2154,7 +2150,7 @@ impl<'a, C, NC, A> PublisherGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PublisherGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PublisherGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2199,10 +2195,10 @@ impl<'a, C, NC, A> PublisherGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct LinkInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LinkInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gan, + hub: &'a Gan, _request: Link, _role: String, _role_id: String, @@ -2210,9 +2206,9 @@ pub struct LinkInsertCall<'a, C, NC, A> _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for LinkInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LinkInsertCall<'a, C, A> {} -impl<'a, C, NC, A> LinkInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LinkInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2350,7 +2346,7 @@ impl<'a, C, NC, A> LinkInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Link) -> LinkInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Link) -> LinkInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2360,7 +2356,7 @@ impl<'a, C, NC, A> LinkInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The role of the requester. Valid values: 'advertisers' or 'publishers'. - pub fn role(mut self, new_value: &str) -> LinkInsertCall<'a, C, NC, A> { + pub fn role(mut self, new_value: &str) -> LinkInsertCall<'a, C, A> { self._role = new_value.to_string(); self } @@ -2370,7 +2366,7 @@ impl<'a, C, NC, A> LinkInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the requesting advertiser or publisher. - pub fn role_id(mut self, new_value: &str) -> LinkInsertCall<'a, C, NC, A> { + pub fn role_id(mut self, new_value: &str) -> LinkInsertCall<'a, C, A> { self._role_id = new_value.to_string(); self } @@ -2381,7 +2377,7 @@ impl<'a, C, NC, A> LinkInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LinkInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LinkInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2402,7 +2398,7 @@ impl<'a, C, NC, A> LinkInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LinkInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LinkInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2441,10 +2437,10 @@ impl<'a, C, NC, A> LinkInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct LinkGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LinkGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gan, + hub: &'a Gan, _role: String, _role_id: String, _link_id: String, @@ -2452,9 +2448,9 @@ pub struct LinkGetCall<'a, C, NC, A> _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for LinkGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LinkGetCall<'a, C, A> {} -impl<'a, C, NC, A> LinkGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LinkGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2586,7 +2582,7 @@ impl<'a, C, NC, A> LinkGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// The role of the requester. Valid values: 'advertisers' or 'publishers'. - pub fn role(mut self, new_value: &str) -> LinkGetCall<'a, C, NC, A> { + pub fn role(mut self, new_value: &str) -> LinkGetCall<'a, C, A> { self._role = new_value.to_string(); self } @@ -2596,7 +2592,7 @@ impl<'a, C, NC, A> LinkGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// The ID of the requesting advertiser or publisher. - pub fn role_id(mut self, new_value: &str) -> LinkGetCall<'a, C, NC, A> { + pub fn role_id(mut self, new_value: &str) -> LinkGetCall<'a, C, A> { self._role_id = new_value.to_string(); self } @@ -2606,7 +2602,7 @@ impl<'a, C, NC, A> LinkGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// The ID of the link to look up. - pub fn link_id(mut self, new_value: &str) -> LinkGetCall<'a, C, NC, A> { + pub fn link_id(mut self, new_value: &str) -> LinkGetCall<'a, C, A> { self._link_id = new_value.to_string(); self } @@ -2617,7 +2613,7 @@ impl<'a, C, NC, A> LinkGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LinkGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LinkGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2638,7 +2634,7 @@ impl<'a, C, NC, A> LinkGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LinkGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LinkGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2690,10 +2686,10 @@ impl<'a, C, NC, A> LinkGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct LinkListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LinkListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gan, + hub: &'a Gan, _role: String, _role_id: String, _start_date_min: Option, @@ -2713,9 +2709,9 @@ pub struct LinkListCall<'a, C, NC, A> _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for LinkListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LinkListCall<'a, C, A> {} -impl<'a, C, NC, A> LinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LinkListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2897,7 +2893,7 @@ impl<'a, C, NC, A> LinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The role of the requester. Valid values: 'advertisers' or 'publishers'. - pub fn role(mut self, new_value: &str) -> LinkListCall<'a, C, NC, A> { + pub fn role(mut self, new_value: &str) -> LinkListCall<'a, C, A> { self._role = new_value.to_string(); self } @@ -2907,7 +2903,7 @@ impl<'a, C, NC, A> LinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The ID of the requesting advertiser or publisher. - pub fn role_id(mut self, new_value: &str) -> LinkListCall<'a, C, NC, A> { + pub fn role_id(mut self, new_value: &str) -> LinkListCall<'a, C, A> { self._role_id = new_value.to_string(); self } @@ -2915,7 +2911,7 @@ impl<'a, C, NC, A> LinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The beginning of the start date range. - pub fn start_date_min(mut self, new_value: &str) -> LinkListCall<'a, C, NC, A> { + pub fn start_date_min(mut self, new_value: &str) -> LinkListCall<'a, C, A> { self._start_date_min = Some(new_value.to_string()); self } @@ -2923,7 +2919,7 @@ impl<'a, C, NC, A> LinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The end of the start date range. - pub fn start_date_max(mut self, new_value: &str) -> LinkListCall<'a, C, NC, A> { + pub fn start_date_max(mut self, new_value: &str) -> LinkListCall<'a, C, A> { self._start_date_max = Some(new_value.to_string()); self } @@ -2931,7 +2927,7 @@ impl<'a, C, NC, A> LinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Field for full text search across title and merchandising text, supports link id search. - pub fn search_text(mut self, new_value: &str) -> LinkListCall<'a, C, NC, A> { + pub fn search_text(mut self, new_value: &str) -> LinkListCall<'a, C, A> { self._search_text = Some(new_value.to_string()); self } @@ -2939,7 +2935,7 @@ impl<'a, C, NC, A> LinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The status of the relationship. - pub fn relationship_status(mut self, new_value: &str) -> LinkListCall<'a, C, NC, A> { + pub fn relationship_status(mut self, new_value: &str) -> LinkListCall<'a, C, A> { self._relationship_status = Some(new_value.to_string()); self } @@ -2948,7 +2944,7 @@ impl<'a, C, NC, A> LinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The promotion type. - pub fn add_promotion_type(mut self, new_value: &str) -> LinkListCall<'a, C, NC, A> { + pub fn add_promotion_type(mut self, new_value: &str) -> LinkListCall<'a, C, A> { self._promotion_type.push(new_value.to_string()); self } @@ -2956,7 +2952,7 @@ impl<'a, C, NC, A> LinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The value of 'nextPageToken' from the previous page. Optional. - pub fn page_token(mut self, new_value: &str) -> LinkListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> LinkListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2964,7 +2960,7 @@ impl<'a, C, NC, A> LinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Max number of items to return in this page. Optional. Defaults to 20. - pub fn max_results(mut self, new_value: u32) -> LinkListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> LinkListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2972,7 +2968,7 @@ impl<'a, C, NC, A> LinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The type of the link. - pub fn link_type(mut self, new_value: &str) -> LinkListCall<'a, C, NC, A> { + pub fn link_type(mut self, new_value: &str) -> LinkListCall<'a, C, A> { self._link_type = Some(new_value.to_string()); self } @@ -2980,7 +2976,7 @@ impl<'a, C, NC, A> LinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The beginning of the create date range. - pub fn create_date_min(mut self, new_value: &str) -> LinkListCall<'a, C, NC, A> { + pub fn create_date_min(mut self, new_value: &str) -> LinkListCall<'a, C, A> { self._create_date_min = Some(new_value.to_string()); self } @@ -2988,7 +2984,7 @@ impl<'a, C, NC, A> LinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The end of the create date range. - pub fn create_date_max(mut self, new_value: &str) -> LinkListCall<'a, C, NC, A> { + pub fn create_date_max(mut self, new_value: &str) -> LinkListCall<'a, C, A> { self._create_date_max = Some(new_value.to_string()); self } @@ -2996,7 +2992,7 @@ impl<'a, C, NC, A> LinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The role of the author of the link. - pub fn authorship(mut self, new_value: &str) -> LinkListCall<'a, C, NC, A> { + pub fn authorship(mut self, new_value: &str) -> LinkListCall<'a, C, A> { self._authorship = Some(new_value.to_string()); self } @@ -3005,7 +3001,7 @@ impl<'a, C, NC, A> LinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// The size of the given asset. - pub fn add_asset_size(mut self, new_value: &str) -> LinkListCall<'a, C, NC, A> { + pub fn add_asset_size(mut self, new_value: &str) -> LinkListCall<'a, C, A> { self._asset_size.push(new_value.to_string()); self } @@ -3014,7 +3010,7 @@ impl<'a, C, NC, A> LinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Limits the resulting links to the ones belonging to the listed advertisers. - pub fn add_advertiser_id(mut self, new_value: &str) -> LinkListCall<'a, C, NC, A> { + pub fn add_advertiser_id(mut self, new_value: &str) -> LinkListCall<'a, C, A> { self._advertiser_id.push(new_value.to_string()); self } @@ -3025,7 +3021,7 @@ impl<'a, C, NC, A> LinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LinkListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LinkListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3046,7 +3042,7 @@ impl<'a, C, NC, A> LinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LinkListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LinkListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3096,10 +3092,10 @@ impl<'a, C, NC, A> LinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct ReportGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gan, + hub: &'a Gan, _role: String, _role_id: String, _report_type: String, @@ -3118,9 +3114,9 @@ pub struct ReportGetCall<'a, C, NC, A> _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for ReportGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReportGetCall<'a, C, A> {} -impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReportGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3301,7 +3297,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The role of the requester. Valid values: 'advertisers' or 'publishers'. - pub fn role(mut self, new_value: &str) -> ReportGetCall<'a, C, NC, A> { + pub fn role(mut self, new_value: &str) -> ReportGetCall<'a, C, A> { self._role = new_value.to_string(); self } @@ -3311,7 +3307,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the requesting advertiser or publisher. - pub fn role_id(mut self, new_value: &str) -> ReportGetCall<'a, C, NC, A> { + pub fn role_id(mut self, new_value: &str) -> ReportGetCall<'a, C, A> { self._role_id = new_value.to_string(); self } @@ -3321,7 +3317,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The type of report being requested. Valid values: 'order_delta'. Required. - pub fn report_type(mut self, new_value: &str) -> ReportGetCall<'a, C, NC, A> { + pub fn report_type(mut self, new_value: &str) -> ReportGetCall<'a, C, A> { self._report_type = new_value.to_string(); self } @@ -3329,7 +3325,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Filters out all events that do not have the given status. Valid values: 'active', 'canceled', or 'invalid'. Optional. - pub fn status(mut self, new_value: &str) -> ReportGetCall<'a, C, NC, A> { + pub fn status(mut self, new_value: &str) -> ReportGetCall<'a, C, A> { self._status = Some(new_value.to_string()); self } @@ -3337,7 +3333,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Offset on which to return results when paging. Optional. - pub fn start_index(mut self, new_value: u32) -> ReportGetCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: u32) -> ReportGetCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -3345,7 +3341,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The start date (inclusive), in RFC 3339 format, for the report data to be returned. Defaults to one day before endDate, if that is given, or yesterday. Optional. - pub fn start_date(mut self, new_value: &str) -> ReportGetCall<'a, C, NC, A> { + pub fn start_date(mut self, new_value: &str) -> ReportGetCall<'a, C, A> { self._start_date = Some(new_value.to_string()); self } @@ -3354,7 +3350,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The IDs of the publishers to look up, if applicable. - pub fn add_publisher_id(mut self, new_value: &str) -> ReportGetCall<'a, C, NC, A> { + pub fn add_publisher_id(mut self, new_value: &str) -> ReportGetCall<'a, C, A> { self._publisher_id.push(new_value.to_string()); self } @@ -3363,7 +3359,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Filters to capture one of the given order IDs. Optional. - pub fn add_order_id(mut self, new_value: &str) -> ReportGetCall<'a, C, NC, A> { + pub fn add_order_id(mut self, new_value: &str) -> ReportGetCall<'a, C, A> { self._order_id.push(new_value.to_string()); self } @@ -3371,7 +3367,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Max number of items to return in this page. Optional. Defaults to return all results. - pub fn max_results(mut self, new_value: u32) -> ReportGetCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> ReportGetCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -3380,7 +3376,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Filters to capture one of given link IDs. Optional. - pub fn add_link_id(mut self, new_value: &str) -> ReportGetCall<'a, C, NC, A> { + pub fn add_link_id(mut self, new_value: &str) -> ReportGetCall<'a, C, A> { self._link_id.push(new_value.to_string()); self } @@ -3388,7 +3384,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Filters out all events that are not of the given type. Valid values: 'action', 'transaction', or 'charge'. Optional. - pub fn event_type(mut self, new_value: &str) -> ReportGetCall<'a, C, NC, A> { + pub fn event_type(mut self, new_value: &str) -> ReportGetCall<'a, C, A> { self._event_type = Some(new_value.to_string()); self } @@ -3396,7 +3392,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The end date (exclusive), in RFC 3339 format, for the report data to be returned. Defaults to one day after startDate, if that is given, or today. Optional. - pub fn end_date(mut self, new_value: &str) -> ReportGetCall<'a, C, NC, A> { + pub fn end_date(mut self, new_value: &str) -> ReportGetCall<'a, C, A> { self._end_date = Some(new_value.to_string()); self } @@ -3404,7 +3400,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Whether or not to calculate totals rows. Optional. - pub fn calculate_totals(mut self, new_value: bool) -> ReportGetCall<'a, C, NC, A> { + pub fn calculate_totals(mut self, new_value: bool) -> ReportGetCall<'a, C, A> { self._calculate_totals = Some(new_value); self } @@ -3413,7 +3409,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The IDs of the advertisers to look up, if applicable. - pub fn add_advertiser_id(mut self, new_value: &str) -> ReportGetCall<'a, C, NC, A> { + pub fn add_advertiser_id(mut self, new_value: &str) -> ReportGetCall<'a, C, A> { self._advertiser_id.push(new_value.to_string()); self } @@ -3424,7 +3420,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3445,7 +3441,7 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReportGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReportGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3486,10 +3482,10 @@ impl<'a, C, NC, A> ReportGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct CcOfferListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CcOfferListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gan, + hub: &'a Gan, _publisher: String, _projection: Option, _advertiser: Vec, @@ -3497,9 +3493,9 @@ pub struct CcOfferListCall<'a, C, NC, A> _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for CcOfferListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CcOfferListCall<'a, C, A> {} -impl<'a, C, NC, A> CcOfferListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CcOfferListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3639,7 +3635,7 @@ impl<'a, C, NC, A> CcOfferListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the publisher in question. - pub fn publisher(mut self, new_value: &str) -> CcOfferListCall<'a, C, NC, A> { + pub fn publisher(mut self, new_value: &str) -> CcOfferListCall<'a, C, A> { self._publisher = new_value.to_string(); self } @@ -3647,7 +3643,7 @@ impl<'a, C, NC, A> CcOfferListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The set of fields to return. - pub fn projection(mut self, new_value: &str) -> CcOfferListCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> CcOfferListCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -3656,7 +3652,7 @@ impl<'a, C, NC, A> CcOfferListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The advertiser ID of a card issuer whose offers to include. Optional, may be repeated. - pub fn add_advertiser(mut self, new_value: &str) -> CcOfferListCall<'a, C, NC, A> { + pub fn add_advertiser(mut self, new_value: &str) -> CcOfferListCall<'a, C, A> { self._advertiser.push(new_value.to_string()); self } @@ -3667,7 +3663,7 @@ impl<'a, C, NC, A> CcOfferListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CcOfferListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CcOfferListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3688,7 +3684,7 @@ impl<'a, C, NC, A> CcOfferListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CcOfferListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CcOfferListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3728,10 +3724,10 @@ impl<'a, C, NC, A> CcOfferListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct AdvertiserGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdvertiserGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gan, + hub: &'a Gan, _role: String, _role_id: String, _advertiser_id: Option, @@ -3739,9 +3735,9 @@ pub struct AdvertiserGetCall<'a, C, NC, A> _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for AdvertiserGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdvertiserGetCall<'a, C, A> {} -impl<'a, C, NC, A> AdvertiserGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdvertiserGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3875,7 +3871,7 @@ impl<'a, C, NC, A> AdvertiserGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The role of the requester. Valid values: 'advertisers' or 'publishers'. - pub fn role(mut self, new_value: &str) -> AdvertiserGetCall<'a, C, NC, A> { + pub fn role(mut self, new_value: &str) -> AdvertiserGetCall<'a, C, A> { self._role = new_value.to_string(); self } @@ -3885,7 +3881,7 @@ impl<'a, C, NC, A> AdvertiserGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the requesting advertiser or publisher. - pub fn role_id(mut self, new_value: &str) -> AdvertiserGetCall<'a, C, NC, A> { + pub fn role_id(mut self, new_value: &str) -> AdvertiserGetCall<'a, C, A> { self._role_id = new_value.to_string(); self } @@ -3893,7 +3889,7 @@ impl<'a, C, NC, A> AdvertiserGetCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// The ID of the advertiser to look up. Optional. - pub fn advertiser_id(mut self, new_value: &str) -> AdvertiserGetCall<'a, C, NC, A> { + pub fn advertiser_id(mut self, new_value: &str) -> AdvertiserGetCall<'a, C, A> { self._advertiser_id = Some(new_value.to_string()); self } @@ -3904,7 +3900,7 @@ impl<'a, C, NC, A> AdvertiserGetCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3925,7 +3921,7 @@ impl<'a, C, NC, A> AdvertiserGetCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdvertiserGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdvertiserGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3971,10 +3967,10 @@ impl<'a, C, NC, A> AdvertiserGetCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct AdvertiserListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AdvertiserListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gan, + hub: &'a Gan, _role: String, _role_id: String, _relationship_status: Option, @@ -3988,9 +3984,9 @@ pub struct AdvertiserListCall<'a, C, NC, A> _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for AdvertiserListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AdvertiserListCall<'a, C, A> {} -impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AdvertiserListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4142,7 +4138,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The role of the requester. Valid values: 'advertisers' or 'publishers'. - pub fn role(mut self, new_value: &str) -> AdvertiserListCall<'a, C, NC, A> { + pub fn role(mut self, new_value: &str) -> AdvertiserListCall<'a, C, A> { self._role = new_value.to_string(); self } @@ -4152,7 +4148,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the requesting advertiser or publisher. - pub fn role_id(mut self, new_value: &str) -> AdvertiserListCall<'a, C, NC, A> { + pub fn role_id(mut self, new_value: &str) -> AdvertiserListCall<'a, C, A> { self._role_id = new_value.to_string(); self } @@ -4160,7 +4156,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Filters out all advertisers for which do not have the given relationship status with the requesting publisher. - pub fn relationship_status(mut self, new_value: &str) -> AdvertiserListCall<'a, C, NC, A> { + pub fn relationship_status(mut self, new_value: &str) -> AdvertiserListCall<'a, C, A> { self._relationship_status = Some(new_value.to_string()); self } @@ -4168,7 +4164,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The value of 'nextPageToken' from the previous page. Optional. - pub fn page_token(mut self, new_value: &str) -> AdvertiserListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AdvertiserListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -4176,7 +4172,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Filters out all advertisers that have a seven day EPC average lower than the given value (inclusive). Min value: 0.0. Optional. - pub fn min_seven_day_epc(mut self, new_value: f64) -> AdvertiserListCall<'a, C, NC, A> { + pub fn min_seven_day_epc(mut self, new_value: f64) -> AdvertiserListCall<'a, C, A> { self._min_seven_day_epc = Some(new_value); self } @@ -4184,7 +4180,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// A value between 1 and 4, where 1 represents the quartile of advertisers with the lowest ranks and 4 represents the quartile of advertisers with the highest ranks. Filters out all advertisers with a lower rank than the given quartile. For example if a 2 was given only advertisers with a payout rank of 25 or higher would be included. Optional. - pub fn min_payout_rank(mut self, new_value: i32) -> AdvertiserListCall<'a, C, NC, A> { + pub fn min_payout_rank(mut self, new_value: i32) -> AdvertiserListCall<'a, C, A> { self._min_payout_rank = Some(new_value); self } @@ -4192,7 +4188,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Filters out all advertisers that have a ninety day EPC average lower than the given value (inclusive). Min value: 0.0. Optional. - pub fn min_ninety_day_epc(mut self, new_value: f64) -> AdvertiserListCall<'a, C, NC, A> { + pub fn min_ninety_day_epc(mut self, new_value: f64) -> AdvertiserListCall<'a, C, A> { self._min_ninety_day_epc = Some(new_value); self } @@ -4200,7 +4196,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Max number of items to return in this page. Optional. Defaults to 20. - pub fn max_results(mut self, new_value: u32) -> AdvertiserListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> AdvertiserListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -4208,7 +4204,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Caret(^) delimted list of advertiser categories. Valid categories are defined here: http://www.google.com/support/affiliatenetwork/advertiser/bin/answer.py?hl=en&answer=107581. Filters out all advertisers not in one of the given advertiser categories. Optional. - pub fn advertiser_category(mut self, new_value: &str) -> AdvertiserListCall<'a, C, NC, A> { + pub fn advertiser_category(mut self, new_value: &str) -> AdvertiserListCall<'a, C, A> { self._advertiser_category = Some(new_value.to_string()); self } @@ -4219,7 +4215,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AdvertiserListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4240,7 +4236,7 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AdvertiserListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AdvertiserListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4295,10 +4291,10 @@ impl<'a, C, NC, A> AdvertiserListCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct EventListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct EventListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gan, + hub: &'a Gan, _role: String, _role_id: String, _type_: Option, @@ -4321,9 +4317,9 @@ pub struct EventListCall<'a, C, NC, A> _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for EventListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for EventListCall<'a, C, A> {} -impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> EventListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4502,7 +4498,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The role of the requester. Valid values: 'advertisers' or 'publishers'. - pub fn role(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn role(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._role = new_value.to_string(); self } @@ -4512,7 +4508,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the requesting advertiser or publisher. - pub fn role_id(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn role_id(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._role_id = new_value.to_string(); self } @@ -4520,7 +4516,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Filters out all events that are not of the given type. Valid values: 'action', 'transaction', 'charge'. Optional. - pub fn type_(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn type_(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._type_ = Some(new_value.to_string()); self } @@ -4528,7 +4524,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Filters out all events that do not have the given status. Valid values: 'active', 'canceled'. Optional. - pub fn status(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn status(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._status = Some(new_value.to_string()); self } @@ -4536,7 +4532,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Caret(^) delimited list of SKUs. Filters out all events that do not reference one of the given SKU. Optional. - pub fn sku(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn sku(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._sku = Some(new_value.to_string()); self } @@ -4544,7 +4540,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Caret(^) delimited list of publisher IDs. Filters out all events that do not reference one of the given publishers IDs. Only used when under advertiser role. Optional. - pub fn publisher_id(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn publisher_id(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._publisher_id = Some(new_value.to_string()); self } @@ -4552,7 +4548,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Caret(^) delimited list of product categories. Filters out all events that do not reference a product in one of the given product categories. Optional. - pub fn product_category(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn product_category(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._product_category = Some(new_value.to_string()); self } @@ -4560,7 +4556,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The value of 'nextPageToken' from the previous page. Optional. - pub fn page_token(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -4568,7 +4564,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Caret(^) delimited list of order IDs. Filters out all events that do not reference one of the given order IDs. Optional. - pub fn order_id(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn order_id(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._order_id = Some(new_value.to_string()); self } @@ -4576,7 +4572,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Filters out all events modified earlier than given date. Optional. Defaults to 24 hours before the current modifyDateMax, if modifyDateMax is explicitly set. - pub fn modify_date_min(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn modify_date_min(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._modify_date_min = Some(new_value.to_string()); self } @@ -4584,7 +4580,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Filters out all events modified later than given date. Optional. Defaults to 24 hours after modifyDateMin, if modifyDateMin is explicitly set. - pub fn modify_date_max(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn modify_date_max(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._modify_date_max = Some(new_value.to_string()); self } @@ -4592,7 +4588,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Caret(^) delimited list of member IDs. Filters out all events that do not reference one of the given member IDs. Optional. - pub fn member_id(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn member_id(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._member_id = Some(new_value.to_string()); self } @@ -4600,7 +4596,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Max number of offers to return in this page. Optional. Defaults to 20. - pub fn max_results(mut self, new_value: u32) -> EventListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> EventListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -4608,7 +4604,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Caret(^) delimited list of link IDs. Filters out all events that do not reference one of the given link IDs. Optional. - pub fn link_id(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn link_id(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._link_id = Some(new_value.to_string()); self } @@ -4616,7 +4612,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Filters out all events earlier than given date. Optional. Defaults to 24 hours from current date/time. - pub fn event_date_min(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn event_date_min(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._event_date_min = Some(new_value.to_string()); self } @@ -4624,7 +4620,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Filters out all events later than given date. Optional. Defaults to 24 hours after eventMin. - pub fn event_date_max(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn event_date_max(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._event_date_max = Some(new_value.to_string()); self } @@ -4632,7 +4628,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Filters out all charge events that are not of the given charge type. Valid values: 'other', 'slotting_fee', 'monthly_minimum', 'tier_bonus', 'credit', 'debit'. Optional. - pub fn charge_type(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn charge_type(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._charge_type = Some(new_value.to_string()); self } @@ -4640,7 +4636,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Caret(^) delimited list of advertiser IDs. Filters out all events that do not reference one of the given advertiser IDs. Only used when under publishers role. Optional. - pub fn advertiser_id(mut self, new_value: &str) -> EventListCall<'a, C, NC, A> { + pub fn advertiser_id(mut self, new_value: &str) -> EventListCall<'a, C, A> { self._advertiser_id = Some(new_value.to_string()); self } @@ -4651,7 +4647,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> EventListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4672,7 +4668,7 @@ impl<'a, C, NC, A> EventListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> EventListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> EventListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self diff --git a/gen/genomics1_beta2/Cargo.toml b/gen/genomics1_beta2/Cargo.toml index 13e9fec562b..fb4be033b6e 100644 --- a/gen/genomics1_beta2/Cargo.toml +++ b/gen/genomics1_beta2/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-genomics1_beta2" -version = "0.1.4+20150326" +version = "0.1.5+20150326" authors = ["Sebastian Thiel "] description = "A complete library to interact with genomics (protocol v1beta2)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/genomics1_beta2" homepage = "https://developers.google.com/genomics/v1beta2/reference" -documentation = "http://byron.github.io/google-apis-rs/google-genomics1_beta2" +documentation = "http://byron.github.io/google-apis-rs/google_genomics1_beta2" license = "MIT" keywords = ["genomics", "google", "protocol", "web", "api"] diff --git a/gen/genomics1_beta2/README.md b/gen/genomics1_beta2/README.md index 659b3b47851..488febbac8e 100644 --- a/gen/genomics1_beta2/README.md +++ b/gen/genomics1_beta2/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-genomics1_beta2` library allows access to all features of the *Google genomics* service. -This documentation was generated from *genomics* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *genomics:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *genomics* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *genomics:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *genomics* *v1_beta2* API can be found at the [official documentation site](https://developers.google.com/genomics/v1beta2/reference). diff --git a/gen/genomics1_beta2/src/cmn.rs b/gen/genomics1_beta2/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/genomics1_beta2/src/cmn.rs +++ b/gen/genomics1_beta2/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/genomics1_beta2/src/lib.rs b/gen/genomics1_beta2/src/lib.rs index 0943993492b..60451ebf8b4 100644 --- a/gen/genomics1_beta2/src/lib.rs +++ b/gen/genomics1_beta2/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *genomics* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *genomics:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *genomics* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *genomics:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *genomics* *v1_beta2* API can be found at the //! [official documentation site](https://developers.google.com/genomics/v1beta2/reference). @@ -224,7 +224,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -333,70 +332,67 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Genomics { +pub struct Genomics { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Genomics {} +impl<'a, C, A> Hub for Genomics {} -impl<'a, C, NC, A> Genomics - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Genomics + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Genomics { + pub fn new(client: C, authenticator: A) -> Genomics { Genomics { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn annotation_sets(&'a self) -> AnnotationSetMethods<'a, C, NC, A> { + pub fn annotation_sets(&'a self) -> AnnotationSetMethods<'a, C, A> { AnnotationSetMethods { hub: &self } } - pub fn annotations(&'a self) -> AnnotationMethods<'a, C, NC, A> { + pub fn annotations(&'a self) -> AnnotationMethods<'a, C, A> { AnnotationMethods { hub: &self } } - pub fn callsets(&'a self) -> CallsetMethods<'a, C, NC, A> { + pub fn callsets(&'a self) -> CallsetMethods<'a, C, A> { CallsetMethods { hub: &self } } - pub fn datasets(&'a self) -> DatasetMethods<'a, C, NC, A> { + pub fn datasets(&'a self) -> DatasetMethods<'a, C, A> { DatasetMethods { hub: &self } } - pub fn experimental(&'a self) -> ExperimentalMethods<'a, C, NC, A> { + pub fn experimental(&'a self) -> ExperimentalMethods<'a, C, A> { ExperimentalMethods { hub: &self } } - pub fn jobs(&'a self) -> JobMethods<'a, C, NC, A> { + pub fn jobs(&'a self) -> JobMethods<'a, C, A> { JobMethods { hub: &self } } - pub fn readgroupsets(&'a self) -> ReadgroupsetMethods<'a, C, NC, A> { + pub fn readgroupsets(&'a self) -> ReadgroupsetMethods<'a, C, A> { ReadgroupsetMethods { hub: &self } } - pub fn reads(&'a self) -> ReadMethods<'a, C, NC, A> { + pub fn reads(&'a self) -> ReadMethods<'a, C, A> { ReadMethods { hub: &self } } - pub fn references(&'a self) -> ReferenceMethods<'a, C, NC, A> { + pub fn references(&'a self) -> ReferenceMethods<'a, C, A> { ReferenceMethods { hub: &self } } - pub fn referencesets(&'a self) -> ReferencesetMethods<'a, C, NC, A> { + pub fn referencesets(&'a self) -> ReferencesetMethods<'a, C, A> { ReferencesetMethods { hub: &self } } - pub fn streaming_variant_store(&'a self) -> StreamingVariantStoreMethods<'a, C, NC, A> { + pub fn streaming_variant_store(&'a self) -> StreamingVariantStoreMethods<'a, C, A> { StreamingVariantStoreMethods { hub: &self } } - pub fn variants(&'a self) -> VariantMethods<'a, C, NC, A> { + pub fn variants(&'a self) -> VariantMethods<'a, C, A> { VariantMethods { hub: &self } } - pub fn variantsets(&'a self) -> VariantsetMethods<'a, C, NC, A> { + pub fn variantsets(&'a self) -> VariantsetMethods<'a, C, A> { VariantsetMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -2439,15 +2435,15 @@ impl RequestValue for SearchReferenceSetsRequest {} /// let rb = hub.datasets(); /// # } /// ``` -pub struct DatasetMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatasetMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, } -impl<'a, C, NC, A> MethodsBuilder for DatasetMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for DatasetMethods<'a, C, A> {} -impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { +impl<'a, C, A> DatasetMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2456,7 +2452,7 @@ impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn create(&self, request: &Dataset) -> DatasetCreateCall<'a, C, NC, A> { + pub fn create(&self, request: &Dataset) -> DatasetCreateCall<'a, C, A> { DatasetCreateCall { hub: self.hub, _request: request.clone(), @@ -2474,7 +2470,7 @@ impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `datasetId` - The ID of the dataset to be updated. - pub fn update(&self, request: &Dataset, dataset_id: &str) -> DatasetUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Dataset, dataset_id: &str) -> DatasetUpdateCall<'a, C, A> { DatasetUpdateCall { hub: self.hub, _request: request.clone(), @@ -2492,7 +2488,7 @@ impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { /// # Arguments /// /// * `datasetId` - The ID of the dataset to be deleted. - pub fn delete(&self, dataset_id: &str) -> DatasetDeleteCall<'a, C, NC, A> { + pub fn delete(&self, dataset_id: &str) -> DatasetDeleteCall<'a, C, A> { DatasetDeleteCall { hub: self.hub, _dataset_id: dataset_id.to_string(), @@ -2509,7 +2505,7 @@ impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { /// # Arguments /// /// * `datasetId` - The ID of the dataset to be undeleted. - pub fn undelete(&self, dataset_id: &str) -> DatasetUndeleteCall<'a, C, NC, A> { + pub fn undelete(&self, dataset_id: &str) -> DatasetUndeleteCall<'a, C, A> { DatasetUndeleteCall { hub: self.hub, _dataset_id: dataset_id.to_string(), @@ -2526,7 +2522,7 @@ impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { /// # Arguments /// /// * `datasetId` - The ID of the dataset. - pub fn get(&self, dataset_id: &str) -> DatasetGetCall<'a, C, NC, A> { + pub fn get(&self, dataset_id: &str) -> DatasetGetCall<'a, C, A> { DatasetGetCall { hub: self.hub, _dataset_id: dataset_id.to_string(), @@ -2544,7 +2540,7 @@ impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `datasetId` - The ID of the dataset to be updated. - pub fn patch(&self, request: &Dataset, dataset_id: &str) -> DatasetPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Dataset, dataset_id: &str) -> DatasetPatchCall<'a, C, A> { DatasetPatchCall { hub: self.hub, _request: request.clone(), @@ -2558,7 +2554,7 @@ impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Lists datasets within a project. - pub fn list(&self) -> DatasetListCall<'a, C, NC, A> { + pub fn list(&self) -> DatasetListCall<'a, C, A> { DatasetListCall { hub: self.hub, _project_number: Default::default(), @@ -2601,15 +2597,15 @@ impl<'a, C, NC, A> DatasetMethods<'a, C, NC, A> { /// let rb = hub.jobs(); /// # } /// ``` -pub struct JobMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct JobMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, } -impl<'a, C, NC, A> MethodsBuilder for JobMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for JobMethods<'a, C, A> {} -impl<'a, C, NC, A> JobMethods<'a, C, NC, A> { +impl<'a, C, A> JobMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2618,7 +2614,7 @@ impl<'a, C, NC, A> JobMethods<'a, C, NC, A> { /// # Arguments /// /// * `jobId` - Required. The ID of the job. - pub fn cancel(&self, job_id: &str) -> JobCancelCall<'a, C, NC, A> { + pub fn cancel(&self, job_id: &str) -> JobCancelCall<'a, C, A> { JobCancelCall { hub: self.hub, _job_id: job_id.to_string(), @@ -2635,7 +2631,7 @@ impl<'a, C, NC, A> JobMethods<'a, C, NC, A> { /// # Arguments /// /// * `jobId` - Required. The ID of the job. - pub fn get(&self, job_id: &str) -> JobGetCall<'a, C, NC, A> { + pub fn get(&self, job_id: &str) -> JobGetCall<'a, C, A> { JobGetCall { hub: self.hub, _job_id: job_id.to_string(), @@ -2652,7 +2648,7 @@ impl<'a, C, NC, A> JobMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn search(&self, request: &SearchJobsRequest) -> JobSearchCall<'a, C, NC, A> { + pub fn search(&self, request: &SearchJobsRequest) -> JobSearchCall<'a, C, A> { JobSearchCall { hub: self.hub, _request: request.clone(), @@ -2693,15 +2689,15 @@ impl<'a, C, NC, A> JobMethods<'a, C, NC, A> { /// let rb = hub.referencesets(); /// # } /// ``` -pub struct ReferencesetMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReferencesetMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, } -impl<'a, C, NC, A> MethodsBuilder for ReferencesetMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ReferencesetMethods<'a, C, A> {} -impl<'a, C, NC, A> ReferencesetMethods<'a, C, NC, A> { +impl<'a, C, A> ReferencesetMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2712,7 +2708,7 @@ impl<'a, C, NC, A> ReferencesetMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn search(&self, request: &SearchReferenceSetsRequest) -> ReferencesetSearchCall<'a, C, NC, A> { + pub fn search(&self, request: &SearchReferenceSetsRequest) -> ReferencesetSearchCall<'a, C, A> { ReferencesetSearchCall { hub: self.hub, _request: request.clone(), @@ -2731,7 +2727,7 @@ impl<'a, C, NC, A> ReferencesetMethods<'a, C, NC, A> { /// # Arguments /// /// * `referenceSetId` - The ID of the reference set. - pub fn get(&self, reference_set_id: &str) -> ReferencesetGetCall<'a, C, NC, A> { + pub fn get(&self, reference_set_id: &str) -> ReferencesetGetCall<'a, C, A> { ReferencesetGetCall { hub: self.hub, _reference_set_id: reference_set_id.to_string(), @@ -2772,15 +2768,15 @@ impl<'a, C, NC, A> ReferencesetMethods<'a, C, NC, A> { /// let rb = hub.streaming_variant_store(); /// # } /// ``` -pub struct StreamingVariantStoreMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct StreamingVariantStoreMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, } -impl<'a, C, NC, A> MethodsBuilder for StreamingVariantStoreMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for StreamingVariantStoreMethods<'a, C, A> {} -impl<'a, C, NC, A> StreamingVariantStoreMethods<'a, C, NC, A> { +impl<'a, C, A> StreamingVariantStoreMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2789,7 +2785,7 @@ impl<'a, C, NC, A> StreamingVariantStoreMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn streamvariants(&self, request: &StreamVariantsRequest) -> StreamingVariantStoreStreamvariantCall<'a, C, NC, A> { + pub fn streamvariants(&self, request: &StreamVariantsRequest) -> StreamingVariantStoreStreamvariantCall<'a, C, A> { StreamingVariantStoreStreamvariantCall { hub: self.hub, _request: request.clone(), @@ -2830,15 +2826,15 @@ impl<'a, C, NC, A> StreamingVariantStoreMethods<'a, C, NC, A> { /// let rb = hub.callsets(); /// # } /// ``` -pub struct CallsetMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CallsetMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, } -impl<'a, C, NC, A> MethodsBuilder for CallsetMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CallsetMethods<'a, C, A> {} -impl<'a, C, NC, A> CallsetMethods<'a, C, NC, A> { +impl<'a, C, A> CallsetMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2847,7 +2843,7 @@ impl<'a, C, NC, A> CallsetMethods<'a, C, NC, A> { /// # Arguments /// /// * `callSetId` - The ID of the call set to be deleted. - pub fn delete(&self, call_set_id: &str) -> CallsetDeleteCall<'a, C, NC, A> { + pub fn delete(&self, call_set_id: &str) -> CallsetDeleteCall<'a, C, A> { CallsetDeleteCall { hub: self.hub, _call_set_id: call_set_id.to_string(), @@ -2866,7 +2862,7 @@ impl<'a, C, NC, A> CallsetMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn search(&self, request: &SearchCallSetsRequest) -> CallsetSearchCall<'a, C, NC, A> { + pub fn search(&self, request: &SearchCallSetsRequest) -> CallsetSearchCall<'a, C, A> { CallsetSearchCall { hub: self.hub, _request: request.clone(), @@ -2884,7 +2880,7 @@ impl<'a, C, NC, A> CallsetMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `callSetId` - The ID of the call set to be updated. - pub fn patch(&self, request: &CallSet, call_set_id: &str) -> CallsetPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &CallSet, call_set_id: &str) -> CallsetPatchCall<'a, C, A> { CallsetPatchCall { hub: self.hub, _request: request.clone(), @@ -2902,7 +2898,7 @@ impl<'a, C, NC, A> CallsetMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn create(&self, request: &CallSet) -> CallsetCreateCall<'a, C, NC, A> { + pub fn create(&self, request: &CallSet) -> CallsetCreateCall<'a, C, A> { CallsetCreateCall { hub: self.hub, _request: request.clone(), @@ -2919,7 +2915,7 @@ impl<'a, C, NC, A> CallsetMethods<'a, C, NC, A> { /// # Arguments /// /// * `callSetId` - The ID of the call set. - pub fn get(&self, call_set_id: &str) -> CallsetGetCall<'a, C, NC, A> { + pub fn get(&self, call_set_id: &str) -> CallsetGetCall<'a, C, A> { CallsetGetCall { hub: self.hub, _call_set_id: call_set_id.to_string(), @@ -2937,7 +2933,7 @@ impl<'a, C, NC, A> CallsetMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `callSetId` - The ID of the call set to be updated. - pub fn update(&self, request: &CallSet, call_set_id: &str) -> CallsetUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &CallSet, call_set_id: &str) -> CallsetUpdateCall<'a, C, A> { CallsetUpdateCall { hub: self.hub, _request: request.clone(), @@ -2979,15 +2975,15 @@ impl<'a, C, NC, A> CallsetMethods<'a, C, NC, A> { /// let rb = hub.reads(); /// # } /// ``` -pub struct ReadMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReadMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, } -impl<'a, C, NC, A> MethodsBuilder for ReadMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ReadMethods<'a, C, A> {} -impl<'a, C, NC, A> ReadMethods<'a, C, NC, A> { +impl<'a, C, A> ReadMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3002,7 +2998,7 @@ impl<'a, C, NC, A> ReadMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn search(&self, request: &SearchReadsRequest) -> ReadSearchCall<'a, C, NC, A> { + pub fn search(&self, request: &SearchReadsRequest) -> ReadSearchCall<'a, C, A> { ReadSearchCall { hub: self.hub, _request: request.clone(), @@ -3043,15 +3039,15 @@ impl<'a, C, NC, A> ReadMethods<'a, C, NC, A> { /// let rb = hub.readgroupsets(); /// # } /// ``` -pub struct ReadgroupsetMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReadgroupsetMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, } -impl<'a, C, NC, A> MethodsBuilder for ReadgroupsetMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ReadgroupsetMethods<'a, C, A> {} -impl<'a, C, NC, A> ReadgroupsetMethods<'a, C, NC, A> { +impl<'a, C, A> ReadgroupsetMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3061,7 +3057,7 @@ impl<'a, C, NC, A> ReadgroupsetMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `readGroupSetId` - The ID of the read group set to be updated. The caller must have WRITE permissions to the dataset associated with this read group set. - pub fn update(&self, request: &ReadGroupSet, read_group_set_id: &str) -> ReadgroupsetUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &ReadGroupSet, read_group_set_id: &str) -> ReadgroupsetUpdateCall<'a, C, A> { ReadgroupsetUpdateCall { hub: self.hub, _request: request.clone(), @@ -3081,7 +3077,7 @@ impl<'a, C, NC, A> ReadgroupsetMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn export(&self, request: &ExportReadGroupSetsRequest) -> ReadgroupsetExportCall<'a, C, NC, A> { + pub fn export(&self, request: &ExportReadGroupSetsRequest) -> ReadgroupsetExportCall<'a, C, A> { ReadgroupsetExportCall { hub: self.hub, _request: request.clone(), @@ -3100,7 +3096,7 @@ impl<'a, C, NC, A> ReadgroupsetMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn import(&self, request: &ImportReadGroupSetsRequest) -> ReadgroupsetImportCall<'a, C, NC, A> { + pub fn import(&self, request: &ImportReadGroupSetsRequest) -> ReadgroupsetImportCall<'a, C, A> { ReadgroupsetImportCall { hub: self.hub, _request: request.clone(), @@ -3118,7 +3114,7 @@ impl<'a, C, NC, A> ReadgroupsetMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `readGroupSetId` - The ID of the read group set to be updated. The caller must have WRITE permissions to the dataset associated with this read group set. - pub fn patch(&self, request: &ReadGroupSet, read_group_set_id: &str) -> ReadgroupsetPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &ReadGroupSet, read_group_set_id: &str) -> ReadgroupsetPatchCall<'a, C, A> { ReadgroupsetPatchCall { hub: self.hub, _request: request.clone(), @@ -3136,7 +3132,7 @@ impl<'a, C, NC, A> ReadgroupsetMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn call(&self, request: &CallReadGroupSetsRequest) -> ReadgroupsetCallCall<'a, C, NC, A> { + pub fn call(&self, request: &CallReadGroupSetsRequest) -> ReadgroupsetCallCall<'a, C, A> { ReadgroupsetCallCall { hub: self.hub, _request: request.clone(), @@ -3153,7 +3149,7 @@ impl<'a, C, NC, A> ReadgroupsetMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn align(&self, request: &AlignReadGroupSetsRequest) -> ReadgroupsetAlignCall<'a, C, NC, A> { + pub fn align(&self, request: &AlignReadGroupSetsRequest) -> ReadgroupsetAlignCall<'a, C, A> { ReadgroupsetAlignCall { hub: self.hub, _request: request.clone(), @@ -3172,7 +3168,7 @@ impl<'a, C, NC, A> ReadgroupsetMethods<'a, C, NC, A> { /// # Arguments /// /// * `readGroupSetId` - Required. The ID of the read group set over which coverage is requested. - pub fn coveragebuckets_list(&self, read_group_set_id: &str) -> ReadgroupsetCoveragebucketListCall<'a, C, NC, A> { + pub fn coveragebuckets_list(&self, read_group_set_id: &str) -> ReadgroupsetCoveragebucketListCall<'a, C, A> { ReadgroupsetCoveragebucketListCall { hub: self.hub, _read_group_set_id: read_group_set_id.to_string(), @@ -3195,7 +3191,7 @@ impl<'a, C, NC, A> ReadgroupsetMethods<'a, C, NC, A> { /// # Arguments /// /// * `readGroupSetId` - The ID of the read group set to be deleted. The caller must have WRITE permissions to the dataset associated with this read group set. - pub fn delete(&self, read_group_set_id: &str) -> ReadgroupsetDeleteCall<'a, C, NC, A> { + pub fn delete(&self, read_group_set_id: &str) -> ReadgroupsetDeleteCall<'a, C, A> { ReadgroupsetDeleteCall { hub: self.hub, _read_group_set_id: read_group_set_id.to_string(), @@ -3214,7 +3210,7 @@ impl<'a, C, NC, A> ReadgroupsetMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn search(&self, request: &SearchReadGroupSetsRequest) -> ReadgroupsetSearchCall<'a, C, NC, A> { + pub fn search(&self, request: &SearchReadGroupSetsRequest) -> ReadgroupsetSearchCall<'a, C, A> { ReadgroupsetSearchCall { hub: self.hub, _request: request.clone(), @@ -3231,7 +3227,7 @@ impl<'a, C, NC, A> ReadgroupsetMethods<'a, C, NC, A> { /// # Arguments /// /// * `readGroupSetId` - The ID of the read group set. - pub fn get(&self, read_group_set_id: &str) -> ReadgroupsetGetCall<'a, C, NC, A> { + pub fn get(&self, read_group_set_id: &str) -> ReadgroupsetGetCall<'a, C, A> { ReadgroupsetGetCall { hub: self.hub, _read_group_set_id: read_group_set_id.to_string(), @@ -3272,15 +3268,15 @@ impl<'a, C, NC, A> ReadgroupsetMethods<'a, C, NC, A> { /// let rb = hub.references(); /// # } /// ``` -pub struct ReferenceMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReferenceMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, } -impl<'a, C, NC, A> MethodsBuilder for ReferenceMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ReferenceMethods<'a, C, A> {} -impl<'a, C, NC, A> ReferenceMethods<'a, C, NC, A> { +impl<'a, C, A> ReferenceMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3291,7 +3287,7 @@ impl<'a, C, NC, A> ReferenceMethods<'a, C, NC, A> { /// # Arguments /// /// * `referenceId` - The ID of the reference. - pub fn bases_list(&self, reference_id: &str) -> ReferenceBaseListCall<'a, C, NC, A> { + pub fn bases_list(&self, reference_id: &str) -> ReferenceBaseListCall<'a, C, A> { ReferenceBaseListCall { hub: self.hub, _reference_id: reference_id.to_string(), @@ -3314,7 +3310,7 @@ impl<'a, C, NC, A> ReferenceMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn search(&self, request: &SearchReferencesRequest) -> ReferenceSearchCall<'a, C, NC, A> { + pub fn search(&self, request: &SearchReferencesRequest) -> ReferenceSearchCall<'a, C, A> { ReferenceSearchCall { hub: self.hub, _request: request.clone(), @@ -3333,7 +3329,7 @@ impl<'a, C, NC, A> ReferenceMethods<'a, C, NC, A> { /// # Arguments /// /// * `referenceId` - The ID of the reference. - pub fn get(&self, reference_id: &str) -> ReferenceGetCall<'a, C, NC, A> { + pub fn get(&self, reference_id: &str) -> ReferenceGetCall<'a, C, A> { ReferenceGetCall { hub: self.hub, _reference_id: reference_id.to_string(), @@ -3374,15 +3370,15 @@ impl<'a, C, NC, A> ReferenceMethods<'a, C, NC, A> { /// let rb = hub.annotation_sets(); /// # } /// ``` -pub struct AnnotationSetMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AnnotationSetMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, } -impl<'a, C, NC, A> MethodsBuilder for AnnotationSetMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AnnotationSetMethods<'a, C, A> {} -impl<'a, C, NC, A> AnnotationSetMethods<'a, C, NC, A> { +impl<'a, C, A> AnnotationSetMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3391,7 +3387,7 @@ impl<'a, C, NC, A> AnnotationSetMethods<'a, C, NC, A> { /// # Arguments /// /// * `annotationSetId` - The ID of the annotation set to be retrieved. - pub fn get(&self, annotation_set_id: &str) -> AnnotationSetGetCall<'a, C, NC, A> { + pub fn get(&self, annotation_set_id: &str) -> AnnotationSetGetCall<'a, C, A> { AnnotationSetGetCall { hub: self.hub, _annotation_set_id: annotation_set_id.to_string(), @@ -3409,7 +3405,7 @@ impl<'a, C, NC, A> AnnotationSetMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `annotationSetId` - The ID of the annotation set to be updated. - pub fn update(&self, request: &AnnotationSet, annotation_set_id: &str) -> AnnotationSetUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &AnnotationSet, annotation_set_id: &str) -> AnnotationSetUpdateCall<'a, C, A> { AnnotationSetUpdateCall { hub: self.hub, _request: request.clone(), @@ -3427,7 +3423,7 @@ impl<'a, C, NC, A> AnnotationSetMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn create(&self, request: &AnnotationSet) -> AnnotationSetCreateCall<'a, C, NC, A> { + pub fn create(&self, request: &AnnotationSet) -> AnnotationSetCreateCall<'a, C, A> { AnnotationSetCreateCall { hub: self.hub, _request: request.clone(), @@ -3444,7 +3440,7 @@ impl<'a, C, NC, A> AnnotationSetMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn search(&self, request: &SearchAnnotationSetsRequest) -> AnnotationSetSearchCall<'a, C, NC, A> { + pub fn search(&self, request: &SearchAnnotationSetsRequest) -> AnnotationSetSearchCall<'a, C, A> { AnnotationSetSearchCall { hub: self.hub, _request: request.clone(), @@ -3462,7 +3458,7 @@ impl<'a, C, NC, A> AnnotationSetMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `annotationSetId` - The ID of the annotation set to be updated. - pub fn patch(&self, request: &AnnotationSet, annotation_set_id: &str) -> AnnotationSetPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &AnnotationSet, annotation_set_id: &str) -> AnnotationSetPatchCall<'a, C, A> { AnnotationSetPatchCall { hub: self.hub, _request: request.clone(), @@ -3480,7 +3476,7 @@ impl<'a, C, NC, A> AnnotationSetMethods<'a, C, NC, A> { /// # Arguments /// /// * `annotationSetId` - The ID of the annotation set to be deleted. - pub fn delete(&self, annotation_set_id: &str) -> AnnotationSetDeleteCall<'a, C, NC, A> { + pub fn delete(&self, annotation_set_id: &str) -> AnnotationSetDeleteCall<'a, C, A> { AnnotationSetDeleteCall { hub: self.hub, _annotation_set_id: annotation_set_id.to_string(), @@ -3521,15 +3517,15 @@ impl<'a, C, NC, A> AnnotationSetMethods<'a, C, NC, A> { /// let rb = hub.variants(); /// # } /// ``` -pub struct VariantMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VariantMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, } -impl<'a, C, NC, A> MethodsBuilder for VariantMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for VariantMethods<'a, C, A> {} -impl<'a, C, NC, A> VariantMethods<'a, C, NC, A> { +impl<'a, C, A> VariantMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3540,7 +3536,7 @@ impl<'a, C, NC, A> VariantMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn search(&self, request: &SearchVariantsRequest) -> VariantSearchCall<'a, C, NC, A> { + pub fn search(&self, request: &SearchVariantsRequest) -> VariantSearchCall<'a, C, A> { VariantSearchCall { hub: self.hub, _request: request.clone(), @@ -3557,7 +3553,7 @@ impl<'a, C, NC, A> VariantMethods<'a, C, NC, A> { /// # Arguments /// /// * `variantId` - The ID of the variant to be deleted. - pub fn delete(&self, variant_id: &str) -> VariantDeleteCall<'a, C, NC, A> { + pub fn delete(&self, variant_id: &str) -> VariantDeleteCall<'a, C, A> { VariantDeleteCall { hub: self.hub, _variant_id: variant_id.to_string(), @@ -3574,7 +3570,7 @@ impl<'a, C, NC, A> VariantMethods<'a, C, NC, A> { /// # Arguments /// /// * `variantId` - The ID of the variant. - pub fn get(&self, variant_id: &str) -> VariantGetCall<'a, C, NC, A> { + pub fn get(&self, variant_id: &str) -> VariantGetCall<'a, C, A> { VariantGetCall { hub: self.hub, _variant_id: variant_id.to_string(), @@ -3591,7 +3587,7 @@ impl<'a, C, NC, A> VariantMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn create(&self, request: &Variant) -> VariantCreateCall<'a, C, NC, A> { + pub fn create(&self, request: &Variant) -> VariantCreateCall<'a, C, A> { VariantCreateCall { hub: self.hub, _request: request.clone(), @@ -3609,7 +3605,7 @@ impl<'a, C, NC, A> VariantMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `variantId` - The ID of the variant to be updated. - pub fn update(&self, request: &Variant, variant_id: &str) -> VariantUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Variant, variant_id: &str) -> VariantUpdateCall<'a, C, A> { VariantUpdateCall { hub: self.hub, _request: request.clone(), @@ -3651,15 +3647,15 @@ impl<'a, C, NC, A> VariantMethods<'a, C, NC, A> { /// let rb = hub.annotations(); /// # } /// ``` -pub struct AnnotationMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AnnotationMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, } -impl<'a, C, NC, A> MethodsBuilder for AnnotationMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AnnotationMethods<'a, C, A> {} -impl<'a, C, NC, A> AnnotationMethods<'a, C, NC, A> { +impl<'a, C, A> AnnotationMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3669,7 +3665,7 @@ impl<'a, C, NC, A> AnnotationMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `annotationId` - The ID of the annotation set to be updated. - pub fn patch(&self, request: &Annotation, annotation_id: &str) -> AnnotationPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Annotation, annotation_id: &str) -> AnnotationPatchCall<'a, C, A> { AnnotationPatchCall { hub: self.hub, _request: request.clone(), @@ -3688,7 +3684,7 @@ impl<'a, C, NC, A> AnnotationMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `annotationId` - The ID of the annotation set to be updated. - pub fn update(&self, request: &Annotation, annotation_id: &str) -> AnnotationUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Annotation, annotation_id: &str) -> AnnotationUpdateCall<'a, C, A> { AnnotationUpdateCall { hub: self.hub, _request: request.clone(), @@ -3706,7 +3702,7 @@ impl<'a, C, NC, A> AnnotationMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn search(&self, request: &SearchAnnotationsRequest) -> AnnotationSearchCall<'a, C, NC, A> { + pub fn search(&self, request: &SearchAnnotationsRequest) -> AnnotationSearchCall<'a, C, A> { AnnotationSearchCall { hub: self.hub, _request: request.clone(), @@ -3723,7 +3719,7 @@ impl<'a, C, NC, A> AnnotationMethods<'a, C, NC, A> { /// # Arguments /// /// * `annotationId` - The ID of the annotation set to be deleted. - pub fn delete(&self, annotation_id: &str) -> AnnotationDeleteCall<'a, C, NC, A> { + pub fn delete(&self, annotation_id: &str) -> AnnotationDeleteCall<'a, C, A> { AnnotationDeleteCall { hub: self.hub, _annotation_id: annotation_id.to_string(), @@ -3740,7 +3736,7 @@ impl<'a, C, NC, A> AnnotationMethods<'a, C, NC, A> { /// # Arguments /// /// * `annotationId` - The ID of the annotation set to be retrieved. - pub fn get(&self, annotation_id: &str) -> AnnotationGetCall<'a, C, NC, A> { + pub fn get(&self, annotation_id: &str) -> AnnotationGetCall<'a, C, A> { AnnotationGetCall { hub: self.hub, _annotation_id: annotation_id.to_string(), @@ -3757,7 +3753,7 @@ impl<'a, C, NC, A> AnnotationMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn create(&self, request: &Annotation) -> AnnotationCreateCall<'a, C, NC, A> { + pub fn create(&self, request: &Annotation) -> AnnotationCreateCall<'a, C, A> { AnnotationCreateCall { hub: self.hub, _request: request.clone(), @@ -3777,7 +3773,7 @@ impl<'a, C, NC, A> AnnotationMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn batch_create(&self, request: &BatchCreateAnnotationsRequest) -> AnnotationBatchCreateCall<'a, C, NC, A> { + pub fn batch_create(&self, request: &BatchCreateAnnotationsRequest) -> AnnotationBatchCreateCall<'a, C, A> { AnnotationBatchCreateCall { hub: self.hub, _request: request.clone(), @@ -3818,15 +3814,15 @@ impl<'a, C, NC, A> AnnotationMethods<'a, C, NC, A> { /// let rb = hub.experimental(); /// # } /// ``` -pub struct ExperimentalMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ExperimentalMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, } -impl<'a, C, NC, A> MethodsBuilder for ExperimentalMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ExperimentalMethods<'a, C, A> {} -impl<'a, C, NC, A> ExperimentalMethods<'a, C, NC, A> { +impl<'a, C, A> ExperimentalMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3835,7 +3831,7 @@ impl<'a, C, NC, A> ExperimentalMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn jobs_create(&self, request: &ExperimentalCreateJobRequest) -> ExperimentalJobCreateCall<'a, C, NC, A> { + pub fn jobs_create(&self, request: &ExperimentalCreateJobRequest) -> ExperimentalJobCreateCall<'a, C, A> { ExperimentalJobCreateCall { hub: self.hub, _request: request.clone(), @@ -3876,15 +3872,15 @@ impl<'a, C, NC, A> ExperimentalMethods<'a, C, NC, A> { /// let rb = hub.variantsets(); /// # } /// ``` -pub struct VariantsetMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VariantsetMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, } -impl<'a, C, NC, A> MethodsBuilder for VariantsetMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for VariantsetMethods<'a, C, A> {} -impl<'a, C, NC, A> VariantsetMethods<'a, C, NC, A> { +impl<'a, C, A> VariantsetMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3894,7 +3890,7 @@ impl<'a, C, NC, A> VariantsetMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `variantSetId` - The ID of the variant to be updated. - pub fn update(&self, request: &VariantSet, variant_set_id: &str) -> VariantsetUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &VariantSet, variant_set_id: &str) -> VariantsetUpdateCall<'a, C, A> { VariantsetUpdateCall { hub: self.hub, _request: request.clone(), @@ -3913,7 +3909,7 @@ impl<'a, C, NC, A> VariantsetMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `variantSetId` - Required. The ID of the variant set that contains variant data which should be exported. The caller must have READ access to this variant set. - pub fn export(&self, request: &ExportVariantSetRequest, variant_set_id: &str) -> VariantsetExportCall<'a, C, NC, A> { + pub fn export(&self, request: &ExportVariantSetRequest, variant_set_id: &str) -> VariantsetExportCall<'a, C, A> { VariantsetExportCall { hub: self.hub, _request: request.clone(), @@ -3932,7 +3928,7 @@ impl<'a, C, NC, A> VariantsetMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `variantSetId` - The ID of the variant to be updated. - pub fn patch(&self, request: &VariantSet, variant_set_id: &str) -> VariantsetPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &VariantSet, variant_set_id: &str) -> VariantsetPatchCall<'a, C, A> { VariantsetPatchCall { hub: self.hub, _request: request.clone(), @@ -3952,7 +3948,7 @@ impl<'a, C, NC, A> VariantsetMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn search(&self, request: &SearchVariantSetsRequest) -> VariantsetSearchCall<'a, C, NC, A> { + pub fn search(&self, request: &SearchVariantSetsRequest) -> VariantsetSearchCall<'a, C, A> { VariantsetSearchCall { hub: self.hub, _request: request.clone(), @@ -3969,7 +3965,7 @@ impl<'a, C, NC, A> VariantsetMethods<'a, C, NC, A> { /// # Arguments /// /// * `variantSetId` - Required. The ID of the variant set. - pub fn get(&self, variant_set_id: &str) -> VariantsetGetCall<'a, C, NC, A> { + pub fn get(&self, variant_set_id: &str) -> VariantsetGetCall<'a, C, A> { VariantsetGetCall { hub: self.hub, _variant_set_id: variant_set_id.to_string(), @@ -3989,7 +3985,7 @@ impl<'a, C, NC, A> VariantsetMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `variantSetId` - The destination variant set. - pub fn merge_variants(&self, request: &MergeVariantsRequest, variant_set_id: &str) -> VariantsetMergeVariantCall<'a, C, NC, A> { + pub fn merge_variants(&self, request: &MergeVariantsRequest, variant_set_id: &str) -> VariantsetMergeVariantCall<'a, C, A> { VariantsetMergeVariantCall { hub: self.hub, _request: request.clone(), @@ -4007,7 +4003,7 @@ impl<'a, C, NC, A> VariantsetMethods<'a, C, NC, A> { /// # Arguments /// /// * `variantSetId` - The ID of the variant set to be deleted. - pub fn delete(&self, variant_set_id: &str) -> VariantsetDeleteCall<'a, C, NC, A> { + pub fn delete(&self, variant_set_id: &str) -> VariantsetDeleteCall<'a, C, A> { VariantsetDeleteCall { hub: self.hub, _variant_set_id: variant_set_id.to_string(), @@ -4027,7 +4023,7 @@ impl<'a, C, NC, A> VariantsetMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `variantSetId` - Required. The variant set to which variant data should be imported. - pub fn import_variants(&self, request: &ImportVariantsRequest, variant_set_id: &str) -> VariantsetImportVariantCall<'a, C, NC, A> { + pub fn import_variants(&self, request: &ImportVariantsRequest, variant_set_id: &str) -> VariantsetImportVariantCall<'a, C, A> { VariantsetImportVariantCall { hub: self.hub, _request: request.clone(), @@ -4083,19 +4079,19 @@ impl<'a, C, NC, A> VariantsetMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct DatasetCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatasetCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: Dataset, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatasetCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatasetCreateCall<'a, C, A> {} -impl<'a, C, NC, A> DatasetCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatasetCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4209,7 +4205,7 @@ impl<'a, C, NC, A> DatasetCreateCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Dataset) -> DatasetCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Dataset) -> DatasetCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4220,7 +4216,7 @@ impl<'a, C, NC, A> DatasetCreateCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4241,7 +4237,7 @@ impl<'a, C, NC, A> DatasetCreateCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatasetCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatasetCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4258,7 +4254,7 @@ impl<'a, C, NC, A> DatasetCreateCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatasetCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatasetCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4302,10 +4298,10 @@ impl<'a, C, NC, A> DatasetCreateCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct DatasetUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatasetUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: Dataset, _dataset_id: String, _delegate: Option<&'a mut Delegate>, @@ -4313,9 +4309,9 @@ pub struct DatasetUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatasetUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatasetUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> DatasetUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatasetUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4454,7 +4450,7 @@ impl<'a, C, NC, A> DatasetUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Dataset) -> DatasetUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Dataset) -> DatasetUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4464,7 +4460,7 @@ impl<'a, C, NC, A> DatasetUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the dataset to be updated. - pub fn dataset_id(mut self, new_value: &str) -> DatasetUpdateCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> DatasetUpdateCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -4475,7 +4471,7 @@ impl<'a, C, NC, A> DatasetUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4496,7 +4492,7 @@ impl<'a, C, NC, A> DatasetUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatasetUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatasetUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4513,7 +4509,7 @@ impl<'a, C, NC, A> DatasetUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatasetUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatasetUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4551,19 +4547,19 @@ impl<'a, C, NC, A> DatasetUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct DatasetDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatasetDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _dataset_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatasetDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatasetDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> DatasetDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatasetDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4684,7 +4680,7 @@ impl<'a, C, NC, A> DatasetDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the dataset to be deleted. - pub fn dataset_id(mut self, new_value: &str) -> DatasetDeleteCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> DatasetDeleteCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -4695,7 +4691,7 @@ impl<'a, C, NC, A> DatasetDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4716,7 +4712,7 @@ impl<'a, C, NC, A> DatasetDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatasetDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatasetDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4733,7 +4729,7 @@ impl<'a, C, NC, A> DatasetDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatasetDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatasetDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4771,19 +4767,19 @@ impl<'a, C, NC, A> DatasetDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct DatasetUndeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatasetUndeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _dataset_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatasetUndeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatasetUndeleteCall<'a, C, A> {} -impl<'a, C, NC, A> DatasetUndeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatasetUndeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4915,7 +4911,7 @@ impl<'a, C, NC, A> DatasetUndeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the dataset to be undeleted. - pub fn dataset_id(mut self, new_value: &str) -> DatasetUndeleteCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> DatasetUndeleteCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -4926,7 +4922,7 @@ impl<'a, C, NC, A> DatasetUndeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetUndeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetUndeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4947,7 +4943,7 @@ impl<'a, C, NC, A> DatasetUndeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatasetUndeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatasetUndeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4964,7 +4960,7 @@ impl<'a, C, NC, A> DatasetUndeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatasetUndeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatasetUndeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5002,19 +4998,19 @@ impl<'a, C, NC, A> DatasetUndeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct DatasetGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatasetGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _dataset_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatasetGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatasetGetCall<'a, C, A> {} -impl<'a, C, NC, A> DatasetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatasetGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5146,7 +5142,7 @@ impl<'a, C, NC, A> DatasetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the dataset. - pub fn dataset_id(mut self, new_value: &str) -> DatasetGetCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> DatasetGetCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -5157,7 +5153,7 @@ impl<'a, C, NC, A> DatasetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5178,7 +5174,7 @@ impl<'a, C, NC, A> DatasetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatasetGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatasetGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5195,7 +5191,7 @@ impl<'a, C, NC, A> DatasetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatasetGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatasetGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5239,10 +5235,10 @@ impl<'a, C, NC, A> DatasetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct DatasetPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatasetPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: Dataset, _dataset_id: String, _delegate: Option<&'a mut Delegate>, @@ -5250,9 +5246,9 @@ pub struct DatasetPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatasetPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatasetPatchCall<'a, C, A> {} -impl<'a, C, NC, A> DatasetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatasetPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5391,7 +5387,7 @@ impl<'a, C, NC, A> DatasetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Dataset) -> DatasetPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Dataset) -> DatasetPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5401,7 +5397,7 @@ impl<'a, C, NC, A> DatasetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the dataset to be updated. - pub fn dataset_id(mut self, new_value: &str) -> DatasetPatchCall<'a, C, NC, A> { + pub fn dataset_id(mut self, new_value: &str) -> DatasetPatchCall<'a, C, A> { self._dataset_id = new_value.to_string(); self } @@ -5412,7 +5408,7 @@ impl<'a, C, NC, A> DatasetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5433,7 +5429,7 @@ impl<'a, C, NC, A> DatasetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatasetPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatasetPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5450,7 +5446,7 @@ impl<'a, C, NC, A> DatasetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatasetPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatasetPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5491,10 +5487,10 @@ impl<'a, C, NC, A> DatasetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct DatasetListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatasetListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _project_number: Option, _page_token: Option, _page_size: Option, @@ -5503,9 +5499,9 @@ pub struct DatasetListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatasetListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatasetListCall<'a, C, A> {} -impl<'a, C, NC, A> DatasetListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatasetListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5619,7 +5615,7 @@ impl<'a, C, NC, A> DatasetListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The project to list datasets for. - pub fn project_number(mut self, new_value: &str) -> DatasetListCall<'a, C, NC, A> { + pub fn project_number(mut self, new_value: &str) -> DatasetListCall<'a, C, A> { self._project_number = Some(new_value.to_string()); self } @@ -5627,7 +5623,7 @@ impl<'a, C, NC, A> DatasetListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The continuation token, which is used to page through large result sets. To get the next page of results, set this parameter to the value of nextPageToken from the previous response. - pub fn page_token(mut self, new_value: &str) -> DatasetListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> DatasetListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -5635,7 +5631,7 @@ impl<'a, C, NC, A> DatasetListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The maximum number of results returned by this request. If unspecified, defaults to 50. - pub fn page_size(mut self, new_value: i32) -> DatasetListCall<'a, C, NC, A> { + pub fn page_size(mut self, new_value: i32) -> DatasetListCall<'a, C, A> { self._page_size = Some(new_value); self } @@ -5646,7 +5642,7 @@ impl<'a, C, NC, A> DatasetListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatasetListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5667,7 +5663,7 @@ impl<'a, C, NC, A> DatasetListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatasetListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatasetListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5684,7 +5680,7 @@ impl<'a, C, NC, A> DatasetListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatasetListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatasetListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5722,19 +5718,19 @@ impl<'a, C, NC, A> DatasetListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct JobCancelCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct JobCancelCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _job_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for JobCancelCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for JobCancelCall<'a, C, A> {} -impl<'a, C, NC, A> JobCancelCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> JobCancelCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5855,7 +5851,7 @@ impl<'a, C, NC, A> JobCancelCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Required. The ID of the job. - pub fn job_id(mut self, new_value: &str) -> JobCancelCall<'a, C, NC, A> { + pub fn job_id(mut self, new_value: &str) -> JobCancelCall<'a, C, A> { self._job_id = new_value.to_string(); self } @@ -5866,7 +5862,7 @@ impl<'a, C, NC, A> JobCancelCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobCancelCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobCancelCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5887,7 +5883,7 @@ impl<'a, C, NC, A> JobCancelCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> JobCancelCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> JobCancelCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5904,7 +5900,7 @@ impl<'a, C, NC, A> JobCancelCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> JobCancelCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> JobCancelCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5942,19 +5938,19 @@ impl<'a, C, NC, A> JobCancelCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct JobGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct JobGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _job_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for JobGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for JobGetCall<'a, C, A> {} -impl<'a, C, NC, A> JobGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> JobGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6086,7 +6082,7 @@ impl<'a, C, NC, A> JobGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// we provide this method for API completeness. /// /// Required. The ID of the job. - pub fn job_id(mut self, new_value: &str) -> JobGetCall<'a, C, NC, A> { + pub fn job_id(mut self, new_value: &str) -> JobGetCall<'a, C, A> { self._job_id = new_value.to_string(); self } @@ -6097,7 +6093,7 @@ impl<'a, C, NC, A> JobGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6118,7 +6114,7 @@ impl<'a, C, NC, A> JobGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> JobGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> JobGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6135,7 +6131,7 @@ impl<'a, C, NC, A> JobGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> JobGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> JobGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6179,19 +6175,19 @@ impl<'a, C, NC, A> JobGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// .doit(); /// # } /// ``` -pub struct JobSearchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct JobSearchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: SearchJobsRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for JobSearchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for JobSearchCall<'a, C, A> {} -impl<'a, C, NC, A> JobSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> JobSearchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6305,7 +6301,7 @@ impl<'a, C, NC, A> JobSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &SearchJobsRequest) -> JobSearchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &SearchJobsRequest) -> JobSearchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6316,7 +6312,7 @@ impl<'a, C, NC, A> JobSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobSearchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> JobSearchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6337,7 +6333,7 @@ impl<'a, C, NC, A> JobSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> JobSearchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> JobSearchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6354,7 +6350,7 @@ impl<'a, C, NC, A> JobSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> JobSearchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> JobSearchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6400,19 +6396,19 @@ impl<'a, C, NC, A> JobSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct ReferencesetSearchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReferencesetSearchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: SearchReferenceSetsRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReferencesetSearchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReferencesetSearchCall<'a, C, A> {} -impl<'a, C, NC, A> ReferencesetSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReferencesetSearchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6526,7 +6522,7 @@ impl<'a, C, NC, A> ReferencesetSearchCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &SearchReferenceSetsRequest) -> ReferencesetSearchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &SearchReferenceSetsRequest) -> ReferencesetSearchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6537,7 +6533,7 @@ impl<'a, C, NC, A> ReferencesetSearchCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReferencesetSearchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReferencesetSearchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6558,7 +6554,7 @@ impl<'a, C, NC, A> ReferencesetSearchCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReferencesetSearchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReferencesetSearchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6575,7 +6571,7 @@ impl<'a, C, NC, A> ReferencesetSearchCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReferencesetSearchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReferencesetSearchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6615,19 +6611,19 @@ impl<'a, C, NC, A> ReferencesetSearchCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct ReferencesetGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReferencesetGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _reference_set_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReferencesetGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReferencesetGetCall<'a, C, A> {} -impl<'a, C, NC, A> ReferencesetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReferencesetGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6759,7 +6755,7 @@ impl<'a, C, NC, A> ReferencesetGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the reference set. - pub fn reference_set_id(mut self, new_value: &str) -> ReferencesetGetCall<'a, C, NC, A> { + pub fn reference_set_id(mut self, new_value: &str) -> ReferencesetGetCall<'a, C, A> { self._reference_set_id = new_value.to_string(); self } @@ -6770,7 +6766,7 @@ impl<'a, C, NC, A> ReferencesetGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReferencesetGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReferencesetGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6791,7 +6787,7 @@ impl<'a, C, NC, A> ReferencesetGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReferencesetGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReferencesetGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6808,7 +6804,7 @@ impl<'a, C, NC, A> ReferencesetGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReferencesetGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReferencesetGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6852,19 +6848,19 @@ impl<'a, C, NC, A> ReferencesetGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct StreamingVariantStoreStreamvariantCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct StreamingVariantStoreStreamvariantCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: StreamVariantsRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for StreamingVariantStoreStreamvariantCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for StreamingVariantStoreStreamvariantCall<'a, C, A> {} -impl<'a, C, NC, A> StreamingVariantStoreStreamvariantCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> StreamingVariantStoreStreamvariantCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6978,7 +6974,7 @@ impl<'a, C, NC, A> StreamingVariantStoreStreamvariantCall<'a, C, NC, A> where NC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &StreamVariantsRequest) -> StreamingVariantStoreStreamvariantCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &StreamVariantsRequest) -> StreamingVariantStoreStreamvariantCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6989,7 +6985,7 @@ impl<'a, C, NC, A> StreamingVariantStoreStreamvariantCall<'a, C, NC, A> where NC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> StreamingVariantStoreStreamvariantCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> StreamingVariantStoreStreamvariantCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7010,7 +7006,7 @@ impl<'a, C, NC, A> StreamingVariantStoreStreamvariantCall<'a, C, NC, A> where NC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> StreamingVariantStoreStreamvariantCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> StreamingVariantStoreStreamvariantCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7027,7 +7023,7 @@ impl<'a, C, NC, A> StreamingVariantStoreStreamvariantCall<'a, C, NC, A> where NC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> StreamingVariantStoreStreamvariantCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> StreamingVariantStoreStreamvariantCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7065,19 +7061,19 @@ impl<'a, C, NC, A> StreamingVariantStoreStreamvariantCall<'a, C, NC, A> where NC /// .doit(); /// # } /// ``` -pub struct CallsetDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CallsetDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _call_set_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CallsetDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CallsetDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> CallsetDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CallsetDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7198,7 +7194,7 @@ impl<'a, C, NC, A> CallsetDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the call set to be deleted. - pub fn call_set_id(mut self, new_value: &str) -> CallsetDeleteCall<'a, C, NC, A> { + pub fn call_set_id(mut self, new_value: &str) -> CallsetDeleteCall<'a, C, A> { self._call_set_id = new_value.to_string(); self } @@ -7209,7 +7205,7 @@ impl<'a, C, NC, A> CallsetDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CallsetDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CallsetDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7230,7 +7226,7 @@ impl<'a, C, NC, A> CallsetDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CallsetDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CallsetDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7247,7 +7243,7 @@ impl<'a, C, NC, A> CallsetDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CallsetDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CallsetDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7293,19 +7289,19 @@ impl<'a, C, NC, A> CallsetDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct CallsetSearchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CallsetSearchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: SearchCallSetsRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CallsetSearchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CallsetSearchCall<'a, C, A> {} -impl<'a, C, NC, A> CallsetSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CallsetSearchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7419,7 +7415,7 @@ impl<'a, C, NC, A> CallsetSearchCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &SearchCallSetsRequest) -> CallsetSearchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &SearchCallSetsRequest) -> CallsetSearchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7430,7 +7426,7 @@ impl<'a, C, NC, A> CallsetSearchCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CallsetSearchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CallsetSearchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7451,7 +7447,7 @@ impl<'a, C, NC, A> CallsetSearchCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CallsetSearchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CallsetSearchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7468,7 +7464,7 @@ impl<'a, C, NC, A> CallsetSearchCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CallsetSearchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CallsetSearchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7512,10 +7508,10 @@ impl<'a, C, NC, A> CallsetSearchCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct CallsetPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CallsetPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: CallSet, _call_set_id: String, _delegate: Option<&'a mut Delegate>, @@ -7523,9 +7519,9 @@ pub struct CallsetPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CallsetPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CallsetPatchCall<'a, C, A> {} -impl<'a, C, NC, A> CallsetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CallsetPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7664,7 +7660,7 @@ impl<'a, C, NC, A> CallsetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CallSet) -> CallsetPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CallSet) -> CallsetPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7674,7 +7670,7 @@ impl<'a, C, NC, A> CallsetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the call set to be updated. - pub fn call_set_id(mut self, new_value: &str) -> CallsetPatchCall<'a, C, NC, A> { + pub fn call_set_id(mut self, new_value: &str) -> CallsetPatchCall<'a, C, A> { self._call_set_id = new_value.to_string(); self } @@ -7685,7 +7681,7 @@ impl<'a, C, NC, A> CallsetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CallsetPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CallsetPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7706,7 +7702,7 @@ impl<'a, C, NC, A> CallsetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CallsetPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CallsetPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7723,7 +7719,7 @@ impl<'a, C, NC, A> CallsetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CallsetPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CallsetPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7767,19 +7763,19 @@ impl<'a, C, NC, A> CallsetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct CallsetCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CallsetCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: CallSet, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CallsetCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CallsetCreateCall<'a, C, A> {} -impl<'a, C, NC, A> CallsetCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CallsetCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7893,7 +7889,7 @@ impl<'a, C, NC, A> CallsetCreateCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CallSet) -> CallsetCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CallSet) -> CallsetCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7904,7 +7900,7 @@ impl<'a, C, NC, A> CallsetCreateCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CallsetCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CallsetCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7925,7 +7921,7 @@ impl<'a, C, NC, A> CallsetCreateCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CallsetCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CallsetCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7942,7 +7938,7 @@ impl<'a, C, NC, A> CallsetCreateCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CallsetCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CallsetCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7980,19 +7976,19 @@ impl<'a, C, NC, A> CallsetCreateCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct CallsetGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CallsetGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _call_set_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CallsetGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CallsetGetCall<'a, C, A> {} -impl<'a, C, NC, A> CallsetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CallsetGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8124,7 +8120,7 @@ impl<'a, C, NC, A> CallsetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the call set. - pub fn call_set_id(mut self, new_value: &str) -> CallsetGetCall<'a, C, NC, A> { + pub fn call_set_id(mut self, new_value: &str) -> CallsetGetCall<'a, C, A> { self._call_set_id = new_value.to_string(); self } @@ -8135,7 +8131,7 @@ impl<'a, C, NC, A> CallsetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CallsetGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CallsetGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8156,7 +8152,7 @@ impl<'a, C, NC, A> CallsetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CallsetGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CallsetGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8173,7 +8169,7 @@ impl<'a, C, NC, A> CallsetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CallsetGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CallsetGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8217,10 +8213,10 @@ impl<'a, C, NC, A> CallsetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct CallsetUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CallsetUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: CallSet, _call_set_id: String, _delegate: Option<&'a mut Delegate>, @@ -8228,9 +8224,9 @@ pub struct CallsetUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CallsetUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CallsetUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> CallsetUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CallsetUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8369,7 +8365,7 @@ impl<'a, C, NC, A> CallsetUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CallSet) -> CallsetUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CallSet) -> CallsetUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8379,7 +8375,7 @@ impl<'a, C, NC, A> CallsetUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the call set to be updated. - pub fn call_set_id(mut self, new_value: &str) -> CallsetUpdateCall<'a, C, NC, A> { + pub fn call_set_id(mut self, new_value: &str) -> CallsetUpdateCall<'a, C, A> { self._call_set_id = new_value.to_string(); self } @@ -8390,7 +8386,7 @@ impl<'a, C, NC, A> CallsetUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CallsetUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CallsetUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8411,7 +8407,7 @@ impl<'a, C, NC, A> CallsetUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CallsetUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CallsetUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8428,7 +8424,7 @@ impl<'a, C, NC, A> CallsetUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CallsetUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CallsetUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8478,19 +8474,19 @@ impl<'a, C, NC, A> CallsetUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct ReadSearchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReadSearchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: SearchReadsRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReadSearchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReadSearchCall<'a, C, A> {} -impl<'a, C, NC, A> ReadSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReadSearchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8604,7 +8600,7 @@ impl<'a, C, NC, A> ReadSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &SearchReadsRequest) -> ReadSearchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &SearchReadsRequest) -> ReadSearchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8615,7 +8611,7 @@ impl<'a, C, NC, A> ReadSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReadSearchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReadSearchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8636,7 +8632,7 @@ impl<'a, C, NC, A> ReadSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReadSearchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReadSearchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8653,7 +8649,7 @@ impl<'a, C, NC, A> ReadSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReadSearchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReadSearchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8697,10 +8693,10 @@ impl<'a, C, NC, A> ReadSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct ReadgroupsetUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReadgroupsetUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: ReadGroupSet, _read_group_set_id: String, _delegate: Option<&'a mut Delegate>, @@ -8708,9 +8704,9 @@ pub struct ReadgroupsetUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReadgroupsetUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReadgroupsetUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ReadgroupsetUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReadgroupsetUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8849,7 +8845,7 @@ impl<'a, C, NC, A> ReadgroupsetUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ReadGroupSet) -> ReadgroupsetUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ReadGroupSet) -> ReadgroupsetUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8859,7 +8855,7 @@ impl<'a, C, NC, A> ReadgroupsetUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The ID of the read group set to be updated. The caller must have WRITE permissions to the dataset associated with this read group set. - pub fn read_group_set_id(mut self, new_value: &str) -> ReadgroupsetUpdateCall<'a, C, NC, A> { + pub fn read_group_set_id(mut self, new_value: &str) -> ReadgroupsetUpdateCall<'a, C, A> { self._read_group_set_id = new_value.to_string(); self } @@ -8870,7 +8866,7 @@ impl<'a, C, NC, A> ReadgroupsetUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReadgroupsetUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReadgroupsetUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8891,7 +8887,7 @@ impl<'a, C, NC, A> ReadgroupsetUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReadgroupsetUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReadgroupsetUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8908,7 +8904,7 @@ impl<'a, C, NC, A> ReadgroupsetUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReadgroupsetUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReadgroupsetUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8954,19 +8950,19 @@ impl<'a, C, NC, A> ReadgroupsetUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct ReadgroupsetExportCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReadgroupsetExportCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: ExportReadGroupSetsRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReadgroupsetExportCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReadgroupsetExportCall<'a, C, A> {} -impl<'a, C, NC, A> ReadgroupsetExportCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReadgroupsetExportCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9080,7 +9076,7 @@ impl<'a, C, NC, A> ReadgroupsetExportCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ExportReadGroupSetsRequest) -> ReadgroupsetExportCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ExportReadGroupSetsRequest) -> ReadgroupsetExportCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9091,7 +9087,7 @@ impl<'a, C, NC, A> ReadgroupsetExportCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReadgroupsetExportCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReadgroupsetExportCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9112,7 +9108,7 @@ impl<'a, C, NC, A> ReadgroupsetExportCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReadgroupsetExportCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReadgroupsetExportCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9129,7 +9125,7 @@ impl<'a, C, NC, A> ReadgroupsetExportCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReadgroupsetExportCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReadgroupsetExportCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9175,19 +9171,19 @@ impl<'a, C, NC, A> ReadgroupsetExportCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct ReadgroupsetImportCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReadgroupsetImportCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: ImportReadGroupSetsRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReadgroupsetImportCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReadgroupsetImportCall<'a, C, A> {} -impl<'a, C, NC, A> ReadgroupsetImportCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReadgroupsetImportCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9301,7 +9297,7 @@ impl<'a, C, NC, A> ReadgroupsetImportCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ImportReadGroupSetsRequest) -> ReadgroupsetImportCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ImportReadGroupSetsRequest) -> ReadgroupsetImportCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9312,7 +9308,7 @@ impl<'a, C, NC, A> ReadgroupsetImportCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReadgroupsetImportCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReadgroupsetImportCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9333,7 +9329,7 @@ impl<'a, C, NC, A> ReadgroupsetImportCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReadgroupsetImportCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReadgroupsetImportCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9350,7 +9346,7 @@ impl<'a, C, NC, A> ReadgroupsetImportCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReadgroupsetImportCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReadgroupsetImportCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9394,10 +9390,10 @@ impl<'a, C, NC, A> ReadgroupsetImportCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct ReadgroupsetPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReadgroupsetPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: ReadGroupSet, _read_group_set_id: String, _delegate: Option<&'a mut Delegate>, @@ -9405,9 +9401,9 @@ pub struct ReadgroupsetPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReadgroupsetPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReadgroupsetPatchCall<'a, C, A> {} -impl<'a, C, NC, A> ReadgroupsetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReadgroupsetPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9546,7 +9542,7 @@ impl<'a, C, NC, A> ReadgroupsetPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ReadGroupSet) -> ReadgroupsetPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ReadGroupSet) -> ReadgroupsetPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9556,7 +9552,7 @@ impl<'a, C, NC, A> ReadgroupsetPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the read group set to be updated. The caller must have WRITE permissions to the dataset associated with this read group set. - pub fn read_group_set_id(mut self, new_value: &str) -> ReadgroupsetPatchCall<'a, C, NC, A> { + pub fn read_group_set_id(mut self, new_value: &str) -> ReadgroupsetPatchCall<'a, C, A> { self._read_group_set_id = new_value.to_string(); self } @@ -9567,7 +9563,7 @@ impl<'a, C, NC, A> ReadgroupsetPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReadgroupsetPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReadgroupsetPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9588,7 +9584,7 @@ impl<'a, C, NC, A> ReadgroupsetPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReadgroupsetPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReadgroupsetPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9605,7 +9601,7 @@ impl<'a, C, NC, A> ReadgroupsetPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReadgroupsetPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReadgroupsetPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9649,19 +9645,19 @@ impl<'a, C, NC, A> ReadgroupsetPatchCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct ReadgroupsetCallCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReadgroupsetCallCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: CallReadGroupSetsRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReadgroupsetCallCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReadgroupsetCallCall<'a, C, A> {} -impl<'a, C, NC, A> ReadgroupsetCallCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReadgroupsetCallCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9775,7 +9771,7 @@ impl<'a, C, NC, A> ReadgroupsetCallCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CallReadGroupSetsRequest) -> ReadgroupsetCallCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CallReadGroupSetsRequest) -> ReadgroupsetCallCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9786,7 +9782,7 @@ impl<'a, C, NC, A> ReadgroupsetCallCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReadgroupsetCallCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReadgroupsetCallCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9807,7 +9803,7 @@ impl<'a, C, NC, A> ReadgroupsetCallCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReadgroupsetCallCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReadgroupsetCallCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9824,7 +9820,7 @@ impl<'a, C, NC, A> ReadgroupsetCallCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReadgroupsetCallCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReadgroupsetCallCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9868,19 +9864,19 @@ impl<'a, C, NC, A> ReadgroupsetCallCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct ReadgroupsetAlignCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReadgroupsetAlignCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: AlignReadGroupSetsRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReadgroupsetAlignCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReadgroupsetAlignCall<'a, C, A> {} -impl<'a, C, NC, A> ReadgroupsetAlignCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReadgroupsetAlignCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9994,7 +9990,7 @@ impl<'a, C, NC, A> ReadgroupsetAlignCall<'a, C, NC, A> where NC: hyper::net::Net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AlignReadGroupSetsRequest) -> ReadgroupsetAlignCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AlignReadGroupSetsRequest) -> ReadgroupsetAlignCall<'a, C, A> { self._request = new_value.clone(); self } @@ -10005,7 +10001,7 @@ impl<'a, C, NC, A> ReadgroupsetAlignCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReadgroupsetAlignCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReadgroupsetAlignCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10026,7 +10022,7 @@ impl<'a, C, NC, A> ReadgroupsetAlignCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReadgroupsetAlignCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReadgroupsetAlignCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10043,7 +10039,7 @@ impl<'a, C, NC, A> ReadgroupsetAlignCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReadgroupsetAlignCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReadgroupsetAlignCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10089,10 +10085,10 @@ impl<'a, C, NC, A> ReadgroupsetAlignCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct ReadgroupsetCoveragebucketListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReadgroupsetCoveragebucketListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _read_group_set_id: String, _target_bucket_width: Option, _range_start: Option, @@ -10105,9 +10101,9 @@ pub struct ReadgroupsetCoveragebucketListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReadgroupsetCoveragebucketListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReadgroupsetCoveragebucketListCall<'a, C, A> {} -impl<'a, C, NC, A> ReadgroupsetCoveragebucketListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReadgroupsetCoveragebucketListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10257,7 +10253,7 @@ impl<'a, C, NC, A> ReadgroupsetCoveragebucketListCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// Required. The ID of the read group set over which coverage is requested. - pub fn read_group_set_id(mut self, new_value: &str) -> ReadgroupsetCoveragebucketListCall<'a, C, NC, A> { + pub fn read_group_set_id(mut self, new_value: &str) -> ReadgroupsetCoveragebucketListCall<'a, C, A> { self._read_group_set_id = new_value.to_string(); self } @@ -10265,7 +10261,7 @@ impl<'a, C, NC, A> ReadgroupsetCoveragebucketListCall<'a, C, NC, A> where NC: hy /// /// /// The desired width of each reported coverage bucket in base pairs. This will be rounded down to the nearest precomputed bucket width; the value of which is returned as bucketWidth in the response. Defaults to infinity (each bucket spans an entire reference sequence) or the length of the target range, if specified. The smallest precomputed bucketWidth is currently 2048 base pairs; this is subject to change. - pub fn target_bucket_width(mut self, new_value: &str) -> ReadgroupsetCoveragebucketListCall<'a, C, NC, A> { + pub fn target_bucket_width(mut self, new_value: &str) -> ReadgroupsetCoveragebucketListCall<'a, C, A> { self._target_bucket_width = Some(new_value.to_string()); self } @@ -10273,7 +10269,7 @@ impl<'a, C, NC, A> ReadgroupsetCoveragebucketListCall<'a, C, NC, A> where NC: hy /// /// /// The start position of the range on the reference, 0-based inclusive. If specified, referenceName must also be specified. - pub fn range_start(mut self, new_value: &str) -> ReadgroupsetCoveragebucketListCall<'a, C, NC, A> { + pub fn range_start(mut self, new_value: &str) -> ReadgroupsetCoveragebucketListCall<'a, C, A> { self._range_start = Some(new_value.to_string()); self } @@ -10281,7 +10277,7 @@ impl<'a, C, NC, A> ReadgroupsetCoveragebucketListCall<'a, C, NC, A> where NC: hy /// /// /// The reference sequence name, for example chr1, 1, or chrX. - pub fn range_reference_name(mut self, new_value: &str) -> ReadgroupsetCoveragebucketListCall<'a, C, NC, A> { + pub fn range_reference_name(mut self, new_value: &str) -> ReadgroupsetCoveragebucketListCall<'a, C, A> { self._range_reference_name = Some(new_value.to_string()); self } @@ -10289,7 +10285,7 @@ impl<'a, C, NC, A> ReadgroupsetCoveragebucketListCall<'a, C, NC, A> where NC: hy /// /// /// The end position of the range on the reference, 0-based exclusive. If specified, referenceName must also be specified. - pub fn range_end(mut self, new_value: &str) -> ReadgroupsetCoveragebucketListCall<'a, C, NC, A> { + pub fn range_end(mut self, new_value: &str) -> ReadgroupsetCoveragebucketListCall<'a, C, A> { self._range_end = Some(new_value.to_string()); self } @@ -10297,7 +10293,7 @@ impl<'a, C, NC, A> ReadgroupsetCoveragebucketListCall<'a, C, NC, A> where NC: hy /// /// /// The continuation token, which is used to page through large result sets. To get the next page of results, set this parameter to the value of nextPageToken from the previous response. - pub fn page_token(mut self, new_value: &str) -> ReadgroupsetCoveragebucketListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ReadgroupsetCoveragebucketListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -10305,7 +10301,7 @@ impl<'a, C, NC, A> ReadgroupsetCoveragebucketListCall<'a, C, NC, A> where NC: hy /// /// /// The maximum number of results to return in a single page. If unspecified, defaults to 1024. The maximum value is 2048. - pub fn page_size(mut self, new_value: i32) -> ReadgroupsetCoveragebucketListCall<'a, C, NC, A> { + pub fn page_size(mut self, new_value: i32) -> ReadgroupsetCoveragebucketListCall<'a, C, A> { self._page_size = Some(new_value); self } @@ -10316,7 +10312,7 @@ impl<'a, C, NC, A> ReadgroupsetCoveragebucketListCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReadgroupsetCoveragebucketListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReadgroupsetCoveragebucketListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10337,7 +10333,7 @@ impl<'a, C, NC, A> ReadgroupsetCoveragebucketListCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReadgroupsetCoveragebucketListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReadgroupsetCoveragebucketListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10354,7 +10350,7 @@ impl<'a, C, NC, A> ReadgroupsetCoveragebucketListCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReadgroupsetCoveragebucketListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReadgroupsetCoveragebucketListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10392,19 +10388,19 @@ impl<'a, C, NC, A> ReadgroupsetCoveragebucketListCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct ReadgroupsetDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReadgroupsetDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _read_group_set_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReadgroupsetDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReadgroupsetDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ReadgroupsetDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReadgroupsetDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10525,7 +10521,7 @@ impl<'a, C, NC, A> ReadgroupsetDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The ID of the read group set to be deleted. The caller must have WRITE permissions to the dataset associated with this read group set. - pub fn read_group_set_id(mut self, new_value: &str) -> ReadgroupsetDeleteCall<'a, C, NC, A> { + pub fn read_group_set_id(mut self, new_value: &str) -> ReadgroupsetDeleteCall<'a, C, A> { self._read_group_set_id = new_value.to_string(); self } @@ -10536,7 +10532,7 @@ impl<'a, C, NC, A> ReadgroupsetDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReadgroupsetDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReadgroupsetDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10557,7 +10553,7 @@ impl<'a, C, NC, A> ReadgroupsetDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReadgroupsetDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReadgroupsetDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10574,7 +10570,7 @@ impl<'a, C, NC, A> ReadgroupsetDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReadgroupsetDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReadgroupsetDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10620,19 +10616,19 @@ impl<'a, C, NC, A> ReadgroupsetDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct ReadgroupsetSearchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReadgroupsetSearchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: SearchReadGroupSetsRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReadgroupsetSearchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReadgroupsetSearchCall<'a, C, A> {} -impl<'a, C, NC, A> ReadgroupsetSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReadgroupsetSearchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10746,7 +10742,7 @@ impl<'a, C, NC, A> ReadgroupsetSearchCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &SearchReadGroupSetsRequest) -> ReadgroupsetSearchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &SearchReadGroupSetsRequest) -> ReadgroupsetSearchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -10757,7 +10753,7 @@ impl<'a, C, NC, A> ReadgroupsetSearchCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReadgroupsetSearchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReadgroupsetSearchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10778,7 +10774,7 @@ impl<'a, C, NC, A> ReadgroupsetSearchCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReadgroupsetSearchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReadgroupsetSearchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10795,7 +10791,7 @@ impl<'a, C, NC, A> ReadgroupsetSearchCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReadgroupsetSearchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReadgroupsetSearchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10833,19 +10829,19 @@ impl<'a, C, NC, A> ReadgroupsetSearchCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct ReadgroupsetGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReadgroupsetGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _read_group_set_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReadgroupsetGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReadgroupsetGetCall<'a, C, A> {} -impl<'a, C, NC, A> ReadgroupsetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReadgroupsetGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10977,7 +10973,7 @@ impl<'a, C, NC, A> ReadgroupsetGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the read group set. - pub fn read_group_set_id(mut self, new_value: &str) -> ReadgroupsetGetCall<'a, C, NC, A> { + pub fn read_group_set_id(mut self, new_value: &str) -> ReadgroupsetGetCall<'a, C, A> { self._read_group_set_id = new_value.to_string(); self } @@ -10988,7 +10984,7 @@ impl<'a, C, NC, A> ReadgroupsetGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReadgroupsetGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReadgroupsetGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11009,7 +11005,7 @@ impl<'a, C, NC, A> ReadgroupsetGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReadgroupsetGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReadgroupsetGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11026,7 +11022,7 @@ impl<'a, C, NC, A> ReadgroupsetGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReadgroupsetGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReadgroupsetGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11070,10 +11066,10 @@ impl<'a, C, NC, A> ReadgroupsetGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct ReferenceBaseListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReferenceBaseListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _reference_id: String, _start: Option, _page_token: Option, @@ -11084,9 +11080,9 @@ pub struct ReferenceBaseListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReferenceBaseListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReferenceBaseListCall<'a, C, A> {} -impl<'a, C, NC, A> ReferenceBaseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReferenceBaseListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11230,7 +11226,7 @@ impl<'a, C, NC, A> ReferenceBaseListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the reference. - pub fn reference_id(mut self, new_value: &str) -> ReferenceBaseListCall<'a, C, NC, A> { + pub fn reference_id(mut self, new_value: &str) -> ReferenceBaseListCall<'a, C, A> { self._reference_id = new_value.to_string(); self } @@ -11238,7 +11234,7 @@ impl<'a, C, NC, A> ReferenceBaseListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The start position (0-based) of this query. Defaults to 0. - pub fn start(mut self, new_value: &str) -> ReferenceBaseListCall<'a, C, NC, A> { + pub fn start(mut self, new_value: &str) -> ReferenceBaseListCall<'a, C, A> { self._start = Some(new_value.to_string()); self } @@ -11246,7 +11242,7 @@ impl<'a, C, NC, A> ReferenceBaseListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The continuation token, which is used to page through large result sets. To get the next page of results, set this parameter to the value of nextPageToken from the previous response. - pub fn page_token(mut self, new_value: &str) -> ReferenceBaseListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ReferenceBaseListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -11254,7 +11250,7 @@ impl<'a, C, NC, A> ReferenceBaseListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Specifies the maximum number of bases to return in a single page. - pub fn page_size(mut self, new_value: i32) -> ReferenceBaseListCall<'a, C, NC, A> { + pub fn page_size(mut self, new_value: i32) -> ReferenceBaseListCall<'a, C, A> { self._page_size = Some(new_value); self } @@ -11262,7 +11258,7 @@ impl<'a, C, NC, A> ReferenceBaseListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The end position (0-based, exclusive) of this query. Defaults to the length of this reference. - pub fn end(mut self, new_value: &str) -> ReferenceBaseListCall<'a, C, NC, A> { + pub fn end(mut self, new_value: &str) -> ReferenceBaseListCall<'a, C, A> { self._end = Some(new_value.to_string()); self } @@ -11273,7 +11269,7 @@ impl<'a, C, NC, A> ReferenceBaseListCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReferenceBaseListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReferenceBaseListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11294,7 +11290,7 @@ impl<'a, C, NC, A> ReferenceBaseListCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReferenceBaseListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReferenceBaseListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11311,7 +11307,7 @@ impl<'a, C, NC, A> ReferenceBaseListCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReferenceBaseListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReferenceBaseListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11357,19 +11353,19 @@ impl<'a, C, NC, A> ReferenceBaseListCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct ReferenceSearchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReferenceSearchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: SearchReferencesRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReferenceSearchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReferenceSearchCall<'a, C, A> {} -impl<'a, C, NC, A> ReferenceSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReferenceSearchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11483,7 +11479,7 @@ impl<'a, C, NC, A> ReferenceSearchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &SearchReferencesRequest) -> ReferenceSearchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &SearchReferencesRequest) -> ReferenceSearchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -11494,7 +11490,7 @@ impl<'a, C, NC, A> ReferenceSearchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReferenceSearchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReferenceSearchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11515,7 +11511,7 @@ impl<'a, C, NC, A> ReferenceSearchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReferenceSearchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReferenceSearchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11532,7 +11528,7 @@ impl<'a, C, NC, A> ReferenceSearchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReferenceSearchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReferenceSearchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11572,19 +11568,19 @@ impl<'a, C, NC, A> ReferenceSearchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct ReferenceGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReferenceGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _reference_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReferenceGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReferenceGetCall<'a, C, A> {} -impl<'a, C, NC, A> ReferenceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReferenceGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11716,7 +11712,7 @@ impl<'a, C, NC, A> ReferenceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the reference. - pub fn reference_id(mut self, new_value: &str) -> ReferenceGetCall<'a, C, NC, A> { + pub fn reference_id(mut self, new_value: &str) -> ReferenceGetCall<'a, C, A> { self._reference_id = new_value.to_string(); self } @@ -11727,7 +11723,7 @@ impl<'a, C, NC, A> ReferenceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReferenceGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReferenceGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11748,7 +11744,7 @@ impl<'a, C, NC, A> ReferenceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReferenceGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReferenceGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11765,7 +11761,7 @@ impl<'a, C, NC, A> ReferenceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReferenceGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReferenceGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11803,19 +11799,19 @@ impl<'a, C, NC, A> ReferenceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct AnnotationSetGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AnnotationSetGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _annotation_set_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AnnotationSetGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AnnotationSetGetCall<'a, C, A> {} -impl<'a, C, NC, A> AnnotationSetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AnnotationSetGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11947,7 +11943,7 @@ impl<'a, C, NC, A> AnnotationSetGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID of the annotation set to be retrieved. - pub fn annotation_set_id(mut self, new_value: &str) -> AnnotationSetGetCall<'a, C, NC, A> { + pub fn annotation_set_id(mut self, new_value: &str) -> AnnotationSetGetCall<'a, C, A> { self._annotation_set_id = new_value.to_string(); self } @@ -11958,7 +11954,7 @@ impl<'a, C, NC, A> AnnotationSetGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationSetGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationSetGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11979,7 +11975,7 @@ impl<'a, C, NC, A> AnnotationSetGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AnnotationSetGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AnnotationSetGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11996,7 +11992,7 @@ impl<'a, C, NC, A> AnnotationSetGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AnnotationSetGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AnnotationSetGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12040,10 +12036,10 @@ impl<'a, C, NC, A> AnnotationSetGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct AnnotationSetUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AnnotationSetUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: AnnotationSet, _annotation_set_id: String, _delegate: Option<&'a mut Delegate>, @@ -12051,9 +12047,9 @@ pub struct AnnotationSetUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AnnotationSetUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AnnotationSetUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AnnotationSetUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AnnotationSetUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12192,7 +12188,7 @@ impl<'a, C, NC, A> AnnotationSetUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AnnotationSet) -> AnnotationSetUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AnnotationSet) -> AnnotationSetUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -12202,7 +12198,7 @@ impl<'a, C, NC, A> AnnotationSetUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The ID of the annotation set to be updated. - pub fn annotation_set_id(mut self, new_value: &str) -> AnnotationSetUpdateCall<'a, C, NC, A> { + pub fn annotation_set_id(mut self, new_value: &str) -> AnnotationSetUpdateCall<'a, C, A> { self._annotation_set_id = new_value.to_string(); self } @@ -12213,7 +12209,7 @@ impl<'a, C, NC, A> AnnotationSetUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationSetUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationSetUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12234,7 +12230,7 @@ impl<'a, C, NC, A> AnnotationSetUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AnnotationSetUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AnnotationSetUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12251,7 +12247,7 @@ impl<'a, C, NC, A> AnnotationSetUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AnnotationSetUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AnnotationSetUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12295,19 +12291,19 @@ impl<'a, C, NC, A> AnnotationSetUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct AnnotationSetCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AnnotationSetCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: AnnotationSet, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AnnotationSetCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AnnotationSetCreateCall<'a, C, A> {} -impl<'a, C, NC, A> AnnotationSetCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AnnotationSetCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12421,7 +12417,7 @@ impl<'a, C, NC, A> AnnotationSetCreateCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AnnotationSet) -> AnnotationSetCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AnnotationSet) -> AnnotationSetCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -12432,7 +12428,7 @@ impl<'a, C, NC, A> AnnotationSetCreateCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationSetCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationSetCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12453,7 +12449,7 @@ impl<'a, C, NC, A> AnnotationSetCreateCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AnnotationSetCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AnnotationSetCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12470,7 +12466,7 @@ impl<'a, C, NC, A> AnnotationSetCreateCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AnnotationSetCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AnnotationSetCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12514,19 +12510,19 @@ impl<'a, C, NC, A> AnnotationSetCreateCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct AnnotationSetSearchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AnnotationSetSearchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: SearchAnnotationSetsRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AnnotationSetSearchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AnnotationSetSearchCall<'a, C, A> {} -impl<'a, C, NC, A> AnnotationSetSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AnnotationSetSearchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12640,7 +12636,7 @@ impl<'a, C, NC, A> AnnotationSetSearchCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &SearchAnnotationSetsRequest) -> AnnotationSetSearchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &SearchAnnotationSetsRequest) -> AnnotationSetSearchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -12651,7 +12647,7 @@ impl<'a, C, NC, A> AnnotationSetSearchCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationSetSearchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationSetSearchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12672,7 +12668,7 @@ impl<'a, C, NC, A> AnnotationSetSearchCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AnnotationSetSearchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AnnotationSetSearchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12689,7 +12685,7 @@ impl<'a, C, NC, A> AnnotationSetSearchCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AnnotationSetSearchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AnnotationSetSearchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12733,10 +12729,10 @@ impl<'a, C, NC, A> AnnotationSetSearchCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct AnnotationSetPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AnnotationSetPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: AnnotationSet, _annotation_set_id: String, _delegate: Option<&'a mut Delegate>, @@ -12744,9 +12740,9 @@ pub struct AnnotationSetPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AnnotationSetPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AnnotationSetPatchCall<'a, C, A> {} -impl<'a, C, NC, A> AnnotationSetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AnnotationSetPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12885,7 +12881,7 @@ impl<'a, C, NC, A> AnnotationSetPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AnnotationSet) -> AnnotationSetPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AnnotationSet) -> AnnotationSetPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -12895,7 +12891,7 @@ impl<'a, C, NC, A> AnnotationSetPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The ID of the annotation set to be updated. - pub fn annotation_set_id(mut self, new_value: &str) -> AnnotationSetPatchCall<'a, C, NC, A> { + pub fn annotation_set_id(mut self, new_value: &str) -> AnnotationSetPatchCall<'a, C, A> { self._annotation_set_id = new_value.to_string(); self } @@ -12906,7 +12902,7 @@ impl<'a, C, NC, A> AnnotationSetPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationSetPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationSetPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12927,7 +12923,7 @@ impl<'a, C, NC, A> AnnotationSetPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AnnotationSetPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AnnotationSetPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12944,7 +12940,7 @@ impl<'a, C, NC, A> AnnotationSetPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AnnotationSetPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AnnotationSetPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12982,19 +12978,19 @@ impl<'a, C, NC, A> AnnotationSetPatchCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct AnnotationSetDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AnnotationSetDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _annotation_set_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AnnotationSetDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AnnotationSetDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> AnnotationSetDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AnnotationSetDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13115,7 +13111,7 @@ impl<'a, C, NC, A> AnnotationSetDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The ID of the annotation set to be deleted. - pub fn annotation_set_id(mut self, new_value: &str) -> AnnotationSetDeleteCall<'a, C, NC, A> { + pub fn annotation_set_id(mut self, new_value: &str) -> AnnotationSetDeleteCall<'a, C, A> { self._annotation_set_id = new_value.to_string(); self } @@ -13126,7 +13122,7 @@ impl<'a, C, NC, A> AnnotationSetDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationSetDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationSetDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13147,7 +13143,7 @@ impl<'a, C, NC, A> AnnotationSetDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AnnotationSetDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AnnotationSetDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13164,7 +13160,7 @@ impl<'a, C, NC, A> AnnotationSetDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AnnotationSetDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AnnotationSetDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13210,19 +13206,19 @@ impl<'a, C, NC, A> AnnotationSetDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct VariantSearchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VariantSearchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: SearchVariantsRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VariantSearchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VariantSearchCall<'a, C, A> {} -impl<'a, C, NC, A> VariantSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VariantSearchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13336,7 +13332,7 @@ impl<'a, C, NC, A> VariantSearchCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &SearchVariantsRequest) -> VariantSearchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &SearchVariantsRequest) -> VariantSearchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13347,7 +13343,7 @@ impl<'a, C, NC, A> VariantSearchCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantSearchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantSearchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13368,7 +13364,7 @@ impl<'a, C, NC, A> VariantSearchCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VariantSearchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VariantSearchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13385,7 +13381,7 @@ impl<'a, C, NC, A> VariantSearchCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VariantSearchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VariantSearchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13423,19 +13419,19 @@ impl<'a, C, NC, A> VariantSearchCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct VariantDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VariantDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _variant_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VariantDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VariantDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> VariantDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VariantDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13556,7 +13552,7 @@ impl<'a, C, NC, A> VariantDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the variant to be deleted. - pub fn variant_id(mut self, new_value: &str) -> VariantDeleteCall<'a, C, NC, A> { + pub fn variant_id(mut self, new_value: &str) -> VariantDeleteCall<'a, C, A> { self._variant_id = new_value.to_string(); self } @@ -13567,7 +13563,7 @@ impl<'a, C, NC, A> VariantDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13588,7 +13584,7 @@ impl<'a, C, NC, A> VariantDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VariantDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VariantDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13605,7 +13601,7 @@ impl<'a, C, NC, A> VariantDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VariantDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VariantDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13643,19 +13639,19 @@ impl<'a, C, NC, A> VariantDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct VariantGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VariantGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _variant_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VariantGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VariantGetCall<'a, C, A> {} -impl<'a, C, NC, A> VariantGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VariantGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13787,7 +13783,7 @@ impl<'a, C, NC, A> VariantGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the variant. - pub fn variant_id(mut self, new_value: &str) -> VariantGetCall<'a, C, NC, A> { + pub fn variant_id(mut self, new_value: &str) -> VariantGetCall<'a, C, A> { self._variant_id = new_value.to_string(); self } @@ -13798,7 +13794,7 @@ impl<'a, C, NC, A> VariantGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13819,7 +13815,7 @@ impl<'a, C, NC, A> VariantGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VariantGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VariantGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13836,7 +13832,7 @@ impl<'a, C, NC, A> VariantGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VariantGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VariantGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13880,19 +13876,19 @@ impl<'a, C, NC, A> VariantGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct VariantCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VariantCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: Variant, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VariantCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VariantCreateCall<'a, C, A> {} -impl<'a, C, NC, A> VariantCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VariantCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14006,7 +14002,7 @@ impl<'a, C, NC, A> VariantCreateCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Variant) -> VariantCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Variant) -> VariantCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -14017,7 +14013,7 @@ impl<'a, C, NC, A> VariantCreateCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14038,7 +14034,7 @@ impl<'a, C, NC, A> VariantCreateCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VariantCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VariantCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14055,7 +14051,7 @@ impl<'a, C, NC, A> VariantCreateCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VariantCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VariantCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14099,10 +14095,10 @@ impl<'a, C, NC, A> VariantCreateCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct VariantUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VariantUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: Variant, _variant_id: String, _delegate: Option<&'a mut Delegate>, @@ -14110,9 +14106,9 @@ pub struct VariantUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VariantUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VariantUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> VariantUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VariantUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14251,7 +14247,7 @@ impl<'a, C, NC, A> VariantUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Variant) -> VariantUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Variant) -> VariantUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -14261,7 +14257,7 @@ impl<'a, C, NC, A> VariantUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the variant to be updated. - pub fn variant_id(mut self, new_value: &str) -> VariantUpdateCall<'a, C, NC, A> { + pub fn variant_id(mut self, new_value: &str) -> VariantUpdateCall<'a, C, A> { self._variant_id = new_value.to_string(); self } @@ -14272,7 +14268,7 @@ impl<'a, C, NC, A> VariantUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14293,7 +14289,7 @@ impl<'a, C, NC, A> VariantUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VariantUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VariantUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14310,7 +14306,7 @@ impl<'a, C, NC, A> VariantUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VariantUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VariantUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14354,10 +14350,10 @@ impl<'a, C, NC, A> VariantUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct AnnotationPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AnnotationPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: Annotation, _annotation_id: String, _delegate: Option<&'a mut Delegate>, @@ -14365,9 +14361,9 @@ pub struct AnnotationPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AnnotationPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AnnotationPatchCall<'a, C, A> {} -impl<'a, C, NC, A> AnnotationPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AnnotationPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14506,7 +14502,7 @@ impl<'a, C, NC, A> AnnotationPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Annotation) -> AnnotationPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Annotation) -> AnnotationPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -14516,7 +14512,7 @@ impl<'a, C, NC, A> AnnotationPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the annotation set to be updated. - pub fn annotation_id(mut self, new_value: &str) -> AnnotationPatchCall<'a, C, NC, A> { + pub fn annotation_id(mut self, new_value: &str) -> AnnotationPatchCall<'a, C, A> { self._annotation_id = new_value.to_string(); self } @@ -14527,7 +14523,7 @@ impl<'a, C, NC, A> AnnotationPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14548,7 +14544,7 @@ impl<'a, C, NC, A> AnnotationPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AnnotationPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AnnotationPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14565,7 +14561,7 @@ impl<'a, C, NC, A> AnnotationPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AnnotationPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AnnotationPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14609,10 +14605,10 @@ impl<'a, C, NC, A> AnnotationPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct AnnotationUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AnnotationUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: Annotation, _annotation_id: String, _delegate: Option<&'a mut Delegate>, @@ -14620,9 +14616,9 @@ pub struct AnnotationUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AnnotationUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AnnotationUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AnnotationUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AnnotationUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14761,7 +14757,7 @@ impl<'a, C, NC, A> AnnotationUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Annotation) -> AnnotationUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Annotation) -> AnnotationUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -14771,7 +14767,7 @@ impl<'a, C, NC, A> AnnotationUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID of the annotation set to be updated. - pub fn annotation_id(mut self, new_value: &str) -> AnnotationUpdateCall<'a, C, NC, A> { + pub fn annotation_id(mut self, new_value: &str) -> AnnotationUpdateCall<'a, C, A> { self._annotation_id = new_value.to_string(); self } @@ -14782,7 +14778,7 @@ impl<'a, C, NC, A> AnnotationUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14803,7 +14799,7 @@ impl<'a, C, NC, A> AnnotationUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AnnotationUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AnnotationUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14820,7 +14816,7 @@ impl<'a, C, NC, A> AnnotationUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AnnotationUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AnnotationUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14864,19 +14860,19 @@ impl<'a, C, NC, A> AnnotationUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct AnnotationSearchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AnnotationSearchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: SearchAnnotationsRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AnnotationSearchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AnnotationSearchCall<'a, C, A> {} -impl<'a, C, NC, A> AnnotationSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AnnotationSearchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14990,7 +14986,7 @@ impl<'a, C, NC, A> AnnotationSearchCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &SearchAnnotationsRequest) -> AnnotationSearchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &SearchAnnotationsRequest) -> AnnotationSearchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -15001,7 +14997,7 @@ impl<'a, C, NC, A> AnnotationSearchCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationSearchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationSearchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15022,7 +15018,7 @@ impl<'a, C, NC, A> AnnotationSearchCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AnnotationSearchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AnnotationSearchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15039,7 +15035,7 @@ impl<'a, C, NC, A> AnnotationSearchCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AnnotationSearchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AnnotationSearchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15077,19 +15073,19 @@ impl<'a, C, NC, A> AnnotationSearchCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct AnnotationDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AnnotationDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _annotation_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AnnotationDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AnnotationDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> AnnotationDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AnnotationDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15210,7 +15206,7 @@ impl<'a, C, NC, A> AnnotationDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID of the annotation set to be deleted. - pub fn annotation_id(mut self, new_value: &str) -> AnnotationDeleteCall<'a, C, NC, A> { + pub fn annotation_id(mut self, new_value: &str) -> AnnotationDeleteCall<'a, C, A> { self._annotation_id = new_value.to_string(); self } @@ -15221,7 +15217,7 @@ impl<'a, C, NC, A> AnnotationDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15242,7 +15238,7 @@ impl<'a, C, NC, A> AnnotationDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AnnotationDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AnnotationDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15259,7 +15255,7 @@ impl<'a, C, NC, A> AnnotationDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AnnotationDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AnnotationDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15297,19 +15293,19 @@ impl<'a, C, NC, A> AnnotationDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct AnnotationGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AnnotationGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _annotation_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AnnotationGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AnnotationGetCall<'a, C, A> {} -impl<'a, C, NC, A> AnnotationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AnnotationGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15441,7 +15437,7 @@ impl<'a, C, NC, A> AnnotationGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the annotation set to be retrieved. - pub fn annotation_id(mut self, new_value: &str) -> AnnotationGetCall<'a, C, NC, A> { + pub fn annotation_id(mut self, new_value: &str) -> AnnotationGetCall<'a, C, A> { self._annotation_id = new_value.to_string(); self } @@ -15452,7 +15448,7 @@ impl<'a, C, NC, A> AnnotationGetCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15473,7 +15469,7 @@ impl<'a, C, NC, A> AnnotationGetCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AnnotationGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AnnotationGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15490,7 +15486,7 @@ impl<'a, C, NC, A> AnnotationGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AnnotationGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AnnotationGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15534,19 +15530,19 @@ impl<'a, C, NC, A> AnnotationGetCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct AnnotationCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AnnotationCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: Annotation, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AnnotationCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AnnotationCreateCall<'a, C, A> {} -impl<'a, C, NC, A> AnnotationCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AnnotationCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15660,7 +15656,7 @@ impl<'a, C, NC, A> AnnotationCreateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Annotation) -> AnnotationCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Annotation) -> AnnotationCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -15671,7 +15667,7 @@ impl<'a, C, NC, A> AnnotationCreateCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15692,7 +15688,7 @@ impl<'a, C, NC, A> AnnotationCreateCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AnnotationCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AnnotationCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15709,7 +15705,7 @@ impl<'a, C, NC, A> AnnotationCreateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AnnotationCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AnnotationCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15756,19 +15752,19 @@ impl<'a, C, NC, A> AnnotationCreateCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct AnnotationBatchCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AnnotationBatchCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: BatchCreateAnnotationsRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AnnotationBatchCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AnnotationBatchCreateCall<'a, C, A> {} -impl<'a, C, NC, A> AnnotationBatchCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AnnotationBatchCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15882,7 +15878,7 @@ impl<'a, C, NC, A> AnnotationBatchCreateCall<'a, C, NC, A> where NC: hyper::net: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &BatchCreateAnnotationsRequest) -> AnnotationBatchCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &BatchCreateAnnotationsRequest) -> AnnotationBatchCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -15893,7 +15889,7 @@ impl<'a, C, NC, A> AnnotationBatchCreateCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationBatchCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AnnotationBatchCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15914,7 +15910,7 @@ impl<'a, C, NC, A> AnnotationBatchCreateCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AnnotationBatchCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AnnotationBatchCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15931,7 +15927,7 @@ impl<'a, C, NC, A> AnnotationBatchCreateCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AnnotationBatchCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AnnotationBatchCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15975,19 +15971,19 @@ impl<'a, C, NC, A> AnnotationBatchCreateCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct ExperimentalJobCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ExperimentalJobCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: ExperimentalCreateJobRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ExperimentalJobCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ExperimentalJobCreateCall<'a, C, A> {} -impl<'a, C, NC, A> ExperimentalJobCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ExperimentalJobCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16101,7 +16097,7 @@ impl<'a, C, NC, A> ExperimentalJobCreateCall<'a, C, NC, A> where NC: hyper::net: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ExperimentalCreateJobRequest) -> ExperimentalJobCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ExperimentalCreateJobRequest) -> ExperimentalJobCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -16112,7 +16108,7 @@ impl<'a, C, NC, A> ExperimentalJobCreateCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ExperimentalJobCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ExperimentalJobCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16133,7 +16129,7 @@ impl<'a, C, NC, A> ExperimentalJobCreateCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ExperimentalJobCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ExperimentalJobCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16150,7 +16146,7 @@ impl<'a, C, NC, A> ExperimentalJobCreateCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ExperimentalJobCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ExperimentalJobCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16194,10 +16190,10 @@ impl<'a, C, NC, A> ExperimentalJobCreateCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct VariantsetUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VariantsetUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: VariantSet, _variant_set_id: String, _delegate: Option<&'a mut Delegate>, @@ -16205,9 +16201,9 @@ pub struct VariantsetUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VariantsetUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VariantsetUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> VariantsetUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VariantsetUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16346,7 +16342,7 @@ impl<'a, C, NC, A> VariantsetUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &VariantSet) -> VariantsetUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &VariantSet) -> VariantsetUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -16356,7 +16352,7 @@ impl<'a, C, NC, A> VariantsetUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID of the variant to be updated. - pub fn variant_set_id(mut self, new_value: &str) -> VariantsetUpdateCall<'a, C, NC, A> { + pub fn variant_set_id(mut self, new_value: &str) -> VariantsetUpdateCall<'a, C, A> { self._variant_set_id = new_value.to_string(); self } @@ -16367,7 +16363,7 @@ impl<'a, C, NC, A> VariantsetUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantsetUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantsetUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16388,7 +16384,7 @@ impl<'a, C, NC, A> VariantsetUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VariantsetUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VariantsetUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16405,7 +16401,7 @@ impl<'a, C, NC, A> VariantsetUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VariantsetUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VariantsetUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16449,10 +16445,10 @@ impl<'a, C, NC, A> VariantsetUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct VariantsetExportCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VariantsetExportCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: ExportVariantSetRequest, _variant_set_id: String, _delegate: Option<&'a mut Delegate>, @@ -16460,9 +16456,9 @@ pub struct VariantsetExportCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VariantsetExportCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VariantsetExportCall<'a, C, A> {} -impl<'a, C, NC, A> VariantsetExportCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VariantsetExportCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16601,7 +16597,7 @@ impl<'a, C, NC, A> VariantsetExportCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ExportVariantSetRequest) -> VariantsetExportCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ExportVariantSetRequest) -> VariantsetExportCall<'a, C, A> { self._request = new_value.clone(); self } @@ -16611,7 +16607,7 @@ impl<'a, C, NC, A> VariantsetExportCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Required. The ID of the variant set that contains variant data which should be exported. The caller must have READ access to this variant set. - pub fn variant_set_id(mut self, new_value: &str) -> VariantsetExportCall<'a, C, NC, A> { + pub fn variant_set_id(mut self, new_value: &str) -> VariantsetExportCall<'a, C, A> { self._variant_set_id = new_value.to_string(); self } @@ -16622,7 +16618,7 @@ impl<'a, C, NC, A> VariantsetExportCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantsetExportCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantsetExportCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16643,7 +16639,7 @@ impl<'a, C, NC, A> VariantsetExportCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VariantsetExportCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VariantsetExportCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16660,7 +16656,7 @@ impl<'a, C, NC, A> VariantsetExportCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VariantsetExportCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VariantsetExportCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16704,10 +16700,10 @@ impl<'a, C, NC, A> VariantsetExportCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct VariantsetPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VariantsetPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: VariantSet, _variant_set_id: String, _delegate: Option<&'a mut Delegate>, @@ -16715,9 +16711,9 @@ pub struct VariantsetPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VariantsetPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VariantsetPatchCall<'a, C, A> {} -impl<'a, C, NC, A> VariantsetPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VariantsetPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16856,7 +16852,7 @@ impl<'a, C, NC, A> VariantsetPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &VariantSet) -> VariantsetPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &VariantSet) -> VariantsetPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -16866,7 +16862,7 @@ impl<'a, C, NC, A> VariantsetPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the variant to be updated. - pub fn variant_set_id(mut self, new_value: &str) -> VariantsetPatchCall<'a, C, NC, A> { + pub fn variant_set_id(mut self, new_value: &str) -> VariantsetPatchCall<'a, C, A> { self._variant_set_id = new_value.to_string(); self } @@ -16877,7 +16873,7 @@ impl<'a, C, NC, A> VariantsetPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantsetPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantsetPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16898,7 +16894,7 @@ impl<'a, C, NC, A> VariantsetPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VariantsetPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VariantsetPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16915,7 +16911,7 @@ impl<'a, C, NC, A> VariantsetPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VariantsetPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VariantsetPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16961,19 +16957,19 @@ impl<'a, C, NC, A> VariantsetPatchCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct VariantsetSearchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VariantsetSearchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: SearchVariantSetsRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VariantsetSearchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VariantsetSearchCall<'a, C, A> {} -impl<'a, C, NC, A> VariantsetSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VariantsetSearchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17087,7 +17083,7 @@ impl<'a, C, NC, A> VariantsetSearchCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &SearchVariantSetsRequest) -> VariantsetSearchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &SearchVariantSetsRequest) -> VariantsetSearchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -17098,7 +17094,7 @@ impl<'a, C, NC, A> VariantsetSearchCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantsetSearchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantsetSearchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17119,7 +17115,7 @@ impl<'a, C, NC, A> VariantsetSearchCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VariantsetSearchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VariantsetSearchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17136,7 +17132,7 @@ impl<'a, C, NC, A> VariantsetSearchCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VariantsetSearchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VariantsetSearchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17174,19 +17170,19 @@ impl<'a, C, NC, A> VariantsetSearchCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct VariantsetGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VariantsetGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _variant_set_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VariantsetGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VariantsetGetCall<'a, C, A> {} -impl<'a, C, NC, A> VariantsetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VariantsetGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17318,7 +17314,7 @@ impl<'a, C, NC, A> VariantsetGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Required. The ID of the variant set. - pub fn variant_set_id(mut self, new_value: &str) -> VariantsetGetCall<'a, C, NC, A> { + pub fn variant_set_id(mut self, new_value: &str) -> VariantsetGetCall<'a, C, A> { self._variant_set_id = new_value.to_string(); self } @@ -17329,7 +17325,7 @@ impl<'a, C, NC, A> VariantsetGetCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantsetGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantsetGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17350,7 +17346,7 @@ impl<'a, C, NC, A> VariantsetGetCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VariantsetGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VariantsetGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17367,7 +17363,7 @@ impl<'a, C, NC, A> VariantsetGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VariantsetGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VariantsetGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17413,10 +17409,10 @@ impl<'a, C, NC, A> VariantsetGetCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct VariantsetMergeVariantCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VariantsetMergeVariantCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: MergeVariantsRequest, _variant_set_id: String, _delegate: Option<&'a mut Delegate>, @@ -17424,9 +17420,9 @@ pub struct VariantsetMergeVariantCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VariantsetMergeVariantCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VariantsetMergeVariantCall<'a, C, A> {} -impl<'a, C, NC, A> VariantsetMergeVariantCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VariantsetMergeVariantCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17554,7 +17550,7 @@ impl<'a, C, NC, A> VariantsetMergeVariantCall<'a, C, NC, A> where NC: hyper::net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &MergeVariantsRequest) -> VariantsetMergeVariantCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &MergeVariantsRequest) -> VariantsetMergeVariantCall<'a, C, A> { self._request = new_value.clone(); self } @@ -17564,7 +17560,7 @@ impl<'a, C, NC, A> VariantsetMergeVariantCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The destination variant set. - pub fn variant_set_id(mut self, new_value: &str) -> VariantsetMergeVariantCall<'a, C, NC, A> { + pub fn variant_set_id(mut self, new_value: &str) -> VariantsetMergeVariantCall<'a, C, A> { self._variant_set_id = new_value.to_string(); self } @@ -17575,7 +17571,7 @@ impl<'a, C, NC, A> VariantsetMergeVariantCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantsetMergeVariantCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantsetMergeVariantCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17596,7 +17592,7 @@ impl<'a, C, NC, A> VariantsetMergeVariantCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VariantsetMergeVariantCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VariantsetMergeVariantCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17613,7 +17609,7 @@ impl<'a, C, NC, A> VariantsetMergeVariantCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VariantsetMergeVariantCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VariantsetMergeVariantCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17651,19 +17647,19 @@ impl<'a, C, NC, A> VariantsetMergeVariantCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct VariantsetDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VariantsetDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _variant_set_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VariantsetDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VariantsetDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> VariantsetDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VariantsetDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17784,7 +17780,7 @@ impl<'a, C, NC, A> VariantsetDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID of the variant set to be deleted. - pub fn variant_set_id(mut self, new_value: &str) -> VariantsetDeleteCall<'a, C, NC, A> { + pub fn variant_set_id(mut self, new_value: &str) -> VariantsetDeleteCall<'a, C, A> { self._variant_set_id = new_value.to_string(); self } @@ -17795,7 +17791,7 @@ impl<'a, C, NC, A> VariantsetDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantsetDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantsetDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17816,7 +17812,7 @@ impl<'a, C, NC, A> VariantsetDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VariantsetDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VariantsetDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17833,7 +17829,7 @@ impl<'a, C, NC, A> VariantsetDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VariantsetDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VariantsetDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17879,10 +17875,10 @@ impl<'a, C, NC, A> VariantsetDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct VariantsetImportVariantCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VariantsetImportVariantCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Genomics, + hub: &'a Genomics, _request: ImportVariantsRequest, _variant_set_id: String, _delegate: Option<&'a mut Delegate>, @@ -17890,9 +17886,9 @@ pub struct VariantsetImportVariantCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VariantsetImportVariantCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VariantsetImportVariantCall<'a, C, A> {} -impl<'a, C, NC, A> VariantsetImportVariantCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VariantsetImportVariantCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18031,7 +18027,7 @@ impl<'a, C, NC, A> VariantsetImportVariantCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ImportVariantsRequest) -> VariantsetImportVariantCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ImportVariantsRequest) -> VariantsetImportVariantCall<'a, C, A> { self._request = new_value.clone(); self } @@ -18041,7 +18037,7 @@ impl<'a, C, NC, A> VariantsetImportVariantCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Required. The variant set to which variant data should be imported. - pub fn variant_set_id(mut self, new_value: &str) -> VariantsetImportVariantCall<'a, C, NC, A> { + pub fn variant_set_id(mut self, new_value: &str) -> VariantsetImportVariantCall<'a, C, A> { self._variant_set_id = new_value.to_string(); self } @@ -18052,7 +18048,7 @@ impl<'a, C, NC, A> VariantsetImportVariantCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantsetImportVariantCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VariantsetImportVariantCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18073,7 +18069,7 @@ impl<'a, C, NC, A> VariantsetImportVariantCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VariantsetImportVariantCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VariantsetImportVariantCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18090,7 +18086,7 @@ impl<'a, C, NC, A> VariantsetImportVariantCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VariantsetImportVariantCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VariantsetImportVariantCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/gmail1/Cargo.toml b/gen/gmail1/Cargo.toml index 3b33f44439b..9e29f76da47 100644 --- a/gen/gmail1/Cargo.toml +++ b/gen/gmail1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-gmail1" -version = "0.1.4+20150303" +version = "0.1.5+20150303" authors = ["Sebastian Thiel "] description = "A complete library to interact with gmail (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/gmail1" homepage = "https://developers.google.com/gmail/api/" -documentation = "http://byron.github.io/google-apis-rs/google-gmail1" +documentation = "http://byron.github.io/google-apis-rs/google_gmail1" license = "MIT" keywords = ["gmail", "google", "protocol", "web", "api"] diff --git a/gen/gmail1/README.md b/gen/gmail1/README.md index 1af69d970e6..49588a52102 100644 --- a/gen/gmail1/README.md +++ b/gen/gmail1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-gmail1` library allows access to all features of the *Google gmail* service. -This documentation was generated from *gmail* crate version *0.1.4+20150303*, where *20150303* is the exact revision of the *gmail:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *gmail* crate version *0.1.5+20150303*, where *20150303* is the exact revision of the *gmail:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *gmail* *v1* API can be found at the [official documentation site](https://developers.google.com/gmail/api/). diff --git a/gen/gmail1/src/cmn.rs b/gen/gmail1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/gmail1/src/cmn.rs +++ b/gen/gmail1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/gmail1/src/lib.rs b/gen/gmail1/src/lib.rs index d503b09b443..dbb49bf6d1d 100644 --- a/gen/gmail1/src/lib.rs +++ b/gen/gmail1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *gmail* crate version *0.1.4+20150303*, where *20150303* is the exact revision of the *gmail:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *gmail* crate version *0.1.5+20150303*, where *20150303* is the exact revision of the *gmail:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *gmail* *v1* API can be found at the //! [official documentation site](https://developers.google.com/gmail/api/). @@ -215,7 +215,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -337,34 +336,31 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Gmail { +pub struct Gmail { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Gmail {} +impl<'a, C, A> Hub for Gmail {} -impl<'a, C, NC, A> Gmail - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Gmail + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Gmail { + pub fn new(client: C, authenticator: A) -> Gmail { Gmail { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn users(&'a self) -> UserMethods<'a, C, NC, A> { + pub fn users(&'a self) -> UserMethods<'a, C, A> { UserMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -889,15 +885,15 @@ impl Part for HistoryLabelRemoved {} /// let rb = hub.users(); /// # } /// ``` -pub struct UserMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, } -impl<'a, C, NC, A> MethodsBuilder for UserMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for UserMethods<'a, C, A> {} -impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { +impl<'a, C, A> UserMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -907,7 +903,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. - pub fn messages_import(&self, request: &Message, user_id: &str) -> UserMessageImportCall<'a, C, NC, A> { + pub fn messages_import(&self, request: &Message, user_id: &str) -> UserMessageImportCall<'a, C, A> { UserMessageImportCall { hub: self.hub, _request: request.clone(), @@ -929,7 +925,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// # Arguments /// /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. - pub fn history_list(&self, user_id: &str) -> UserHistoryListCall<'a, C, NC, A> { + pub fn history_list(&self, user_id: &str) -> UserHistoryListCall<'a, C, A> { UserHistoryListCall { hub: self.hub, _user_id: user_id.to_string(), @@ -951,7 +947,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. - pub fn drafts_create(&self, request: &Draft, user_id: &str) -> UserDraftCreateCall<'a, C, NC, A> { + pub fn drafts_create(&self, request: &Draft, user_id: &str) -> UserDraftCreateCall<'a, C, A> { UserDraftCreateCall { hub: self.hub, _request: request.clone(), @@ -970,7 +966,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. - pub fn labels_create(&self, request: &Label, user_id: &str) -> UserLabelCreateCall<'a, C, NC, A> { + pub fn labels_create(&self, request: &Label, user_id: &str) -> UserLabelCreateCall<'a, C, A> { UserLabelCreateCall { hub: self.hub, _request: request.clone(), @@ -989,7 +985,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. /// * `id` - The ID of the label to delete. - pub fn labels_delete(&self, user_id: &str, id: &str) -> UserLabelDeleteCall<'a, C, NC, A> { + pub fn labels_delete(&self, user_id: &str, id: &str) -> UserLabelDeleteCall<'a, C, A> { UserLabelDeleteCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1008,7 +1004,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. /// * `id` - The ID of the label to retrieve. - pub fn labels_get(&self, user_id: &str, id: &str) -> UserLabelGetCall<'a, C, NC, A> { + pub fn labels_get(&self, user_id: &str, id: &str) -> UserLabelGetCall<'a, C, A> { UserLabelGetCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1027,7 +1023,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. /// * `id` - The ID of the message to Trash. - pub fn messages_trash(&self, user_id: &str, id: &str) -> UserMessageTrashCall<'a, C, NC, A> { + pub fn messages_trash(&self, user_id: &str, id: &str) -> UserMessageTrashCall<'a, C, A> { UserMessageTrashCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1046,7 +1042,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. - pub fn drafts_send(&self, request: &Draft, user_id: &str) -> UserDraftSendCall<'a, C, NC, A> { + pub fn drafts_send(&self, request: &Draft, user_id: &str) -> UserDraftSendCall<'a, C, A> { UserDraftSendCall { hub: self.hub, _request: request.clone(), @@ -1065,7 +1061,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. /// * `id` - The ID of the message to remove from Trash. - pub fn messages_untrash(&self, user_id: &str, id: &str) -> UserMessageUntrashCall<'a, C, NC, A> { + pub fn messages_untrash(&self, user_id: &str, id: &str) -> UserMessageUntrashCall<'a, C, A> { UserMessageUntrashCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1083,7 +1079,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// # Arguments /// /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. - pub fn labels_list(&self, user_id: &str) -> UserLabelListCall<'a, C, NC, A> { + pub fn labels_list(&self, user_id: &str) -> UserLabelListCall<'a, C, A> { UserLabelListCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1101,7 +1097,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. /// * `id` - The ID of the message to delete. - pub fn messages_delete(&self, user_id: &str, id: &str) -> UserMessageDeleteCall<'a, C, NC, A> { + pub fn messages_delete(&self, user_id: &str, id: &str) -> UserMessageDeleteCall<'a, C, A> { UserMessageDeleteCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1121,7 +1117,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. /// * `id` - The ID of the draft to update. - pub fn drafts_update(&self, request: &Draft, user_id: &str, id: &str) -> UserDraftUpdateCall<'a, C, NC, A> { + pub fn drafts_update(&self, request: &Draft, user_id: &str, id: &str) -> UserDraftUpdateCall<'a, C, A> { UserDraftUpdateCall { hub: self.hub, _request: request.clone(), @@ -1141,7 +1137,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. /// * `id` - The ID of the draft to retrieve. - pub fn drafts_get(&self, user_id: &str, id: &str) -> UserDraftGetCall<'a, C, NC, A> { + pub fn drafts_get(&self, user_id: &str, id: &str) -> UserDraftGetCall<'a, C, A> { UserDraftGetCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1162,7 +1158,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. /// * `id` - The ID of the label to update. - pub fn labels_update(&self, request: &Label, user_id: &str, id: &str) -> UserLabelUpdateCall<'a, C, NC, A> { + pub fn labels_update(&self, request: &Label, user_id: &str, id: &str) -> UserLabelUpdateCall<'a, C, A> { UserLabelUpdateCall { hub: self.hub, _request: request.clone(), @@ -1182,7 +1178,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. /// * `id` - The ID of the thread to remove from Trash. - pub fn threads_untrash(&self, user_id: &str, id: &str) -> UserThreadUntrashCall<'a, C, NC, A> { + pub fn threads_untrash(&self, user_id: &str, id: &str) -> UserThreadUntrashCall<'a, C, A> { UserThreadUntrashCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1202,7 +1198,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. /// * `id` - The ID of the label to update. - pub fn labels_patch(&self, request: &Label, user_id: &str, id: &str) -> UserLabelPatchCall<'a, C, NC, A> { + pub fn labels_patch(&self, request: &Label, user_id: &str, id: &str) -> UserLabelPatchCall<'a, C, A> { UserLabelPatchCall { hub: self.hub, _request: request.clone(), @@ -1222,7 +1218,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. /// * `id` - The ID of the draft to delete. - pub fn drafts_delete(&self, user_id: &str, id: &str) -> UserDraftDeleteCall<'a, C, NC, A> { + pub fn drafts_delete(&self, user_id: &str, id: &str) -> UserDraftDeleteCall<'a, C, A> { UserDraftDeleteCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1240,7 +1236,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// # Arguments /// /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. - pub fn threads_list(&self, user_id: &str) -> UserThreadListCall<'a, C, NC, A> { + pub fn threads_list(&self, user_id: &str) -> UserThreadListCall<'a, C, A> { UserThreadListCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1264,7 +1260,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. /// * `id` - The ID of the thread to modify. - pub fn threads_modify(&self, request: &ModifyThreadRequest, user_id: &str, id: &str) -> UserThreadModifyCall<'a, C, NC, A> { + pub fn threads_modify(&self, request: &ModifyThreadRequest, user_id: &str, id: &str) -> UserThreadModifyCall<'a, C, A> { UserThreadModifyCall { hub: self.hub, _request: request.clone(), @@ -1284,7 +1280,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. /// * `id` - ID of the Thread to delete. - pub fn threads_delete(&self, user_id: &str, id: &str) -> UserThreadDeleteCall<'a, C, NC, A> { + pub fn threads_delete(&self, user_id: &str, id: &str) -> UserThreadDeleteCall<'a, C, A> { UserThreadDeleteCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1304,7 +1300,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. /// * `messageId` - The ID of the message containing the attachment. /// * `id` - The ID of the attachment. - pub fn messages_attachments_get(&self, user_id: &str, message_id: &str, id: &str) -> UserMessageAttachmentGetCall<'a, C, NC, A> { + pub fn messages_attachments_get(&self, user_id: &str, message_id: &str, id: &str) -> UserMessageAttachmentGetCall<'a, C, A> { UserMessageAttachmentGetCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1325,7 +1321,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. /// * `id` - The ID of the message to modify. - pub fn messages_modify(&self, request: &ModifyMessageRequest, user_id: &str, id: &str) -> UserMessageModifyCall<'a, C, NC, A> { + pub fn messages_modify(&self, request: &ModifyMessageRequest, user_id: &str, id: &str) -> UserMessageModifyCall<'a, C, A> { UserMessageModifyCall { hub: self.hub, _request: request.clone(), @@ -1345,7 +1341,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. /// * `id` - The ID of the thread to Trash. - pub fn threads_trash(&self, user_id: &str, id: &str) -> UserThreadTrashCall<'a, C, NC, A> { + pub fn threads_trash(&self, user_id: &str, id: &str) -> UserThreadTrashCall<'a, C, A> { UserThreadTrashCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1363,7 +1359,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// # Arguments /// /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. - pub fn drafts_list(&self, user_id: &str) -> UserDraftListCall<'a, C, NC, A> { + pub fn drafts_list(&self, user_id: &str) -> UserDraftListCall<'a, C, A> { UserDraftListCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1383,7 +1379,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. - pub fn messages_send(&self, request: &Message, user_id: &str) -> UserMessageSendCall<'a, C, NC, A> { + pub fn messages_send(&self, request: &Message, user_id: &str) -> UserMessageSendCall<'a, C, A> { UserMessageSendCall { hub: self.hub, _request: request.clone(), @@ -1402,7 +1398,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. /// * `id` - The ID of the message to retrieve. - pub fn messages_get(&self, user_id: &str, id: &str) -> UserMessageGetCall<'a, C, NC, A> { + pub fn messages_get(&self, user_id: &str, id: &str) -> UserMessageGetCall<'a, C, A> { UserMessageGetCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1422,7 +1418,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// # Arguments /// /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. - pub fn messages_list(&self, user_id: &str) -> UserMessageListCall<'a, C, NC, A> { + pub fn messages_list(&self, user_id: &str) -> UserMessageListCall<'a, C, A> { UserMessageListCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1444,7 +1440,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// # Arguments /// /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. - pub fn get_profile(&self, user_id: &str) -> UserGetProfileCall<'a, C, NC, A> { + pub fn get_profile(&self, user_id: &str) -> UserGetProfileCall<'a, C, A> { UserGetProfileCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1462,7 +1458,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. /// * `id` - The ID of the thread to retrieve. - pub fn threads_get(&self, user_id: &str, id: &str) -> UserThreadGetCall<'a, C, NC, A> { + pub fn threads_get(&self, user_id: &str, id: &str) -> UserThreadGetCall<'a, C, A> { UserThreadGetCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1483,7 +1479,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `userId` - The user's email address. The special value me can be used to indicate the authenticated user. - pub fn messages_insert(&self, request: &Message, user_id: &str) -> UserMessageInsertCall<'a, C, NC, A> { + pub fn messages_insert(&self, request: &Message, user_id: &str) -> UserMessageInsertCall<'a, C, A> { UserMessageInsertCall { hub: self.hub, _request: request.clone(), @@ -1546,10 +1542,10 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// .upload(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct UserMessageImportCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserMessageImportCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _request: Message, _user_id: String, _process_for_calendar: Option, @@ -1561,9 +1557,9 @@ pub struct UserMessageImportCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserMessageImportCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserMessageImportCall<'a, C, A> {} -impl<'a, C, NC, A> UserMessageImportCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserMessageImportCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1828,7 +1824,7 @@ impl<'a, C, NC, A> UserMessageImportCall<'a, C, NC, A> where NC: hyper::net::Net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Message) -> UserMessageImportCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Message) -> UserMessageImportCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1838,7 +1834,7 @@ impl<'a, C, NC, A> UserMessageImportCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserMessageImportCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserMessageImportCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -1846,7 +1842,7 @@ impl<'a, C, NC, A> UserMessageImportCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Process calendar invites in the email and add any extracted meetings to the Google Calendar for this user. - pub fn process_for_calendar(mut self, new_value: bool) -> UserMessageImportCall<'a, C, NC, A> { + pub fn process_for_calendar(mut self, new_value: bool) -> UserMessageImportCall<'a, C, A> { self._process_for_calendar = Some(new_value); self } @@ -1854,7 +1850,7 @@ impl<'a, C, NC, A> UserMessageImportCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Ignore the Gmail spam classifier decision and never mark this email as SPAM in the mailbox. - pub fn never_mark_spam(mut self, new_value: bool) -> UserMessageImportCall<'a, C, NC, A> { + pub fn never_mark_spam(mut self, new_value: bool) -> UserMessageImportCall<'a, C, A> { self._never_mark_spam = Some(new_value); self } @@ -1862,7 +1858,7 @@ impl<'a, C, NC, A> UserMessageImportCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Source for Gmail's internal date of the message. - pub fn internal_date_source(mut self, new_value: &str) -> UserMessageImportCall<'a, C, NC, A> { + pub fn internal_date_source(mut self, new_value: &str) -> UserMessageImportCall<'a, C, A> { self._internal_date_source = Some(new_value.to_string()); self } @@ -1870,7 +1866,7 @@ impl<'a, C, NC, A> UserMessageImportCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Mark the email as permanently deleted (not TRASH) and only visible in Google Apps Vault to a Vault administrator. Only used for Google Apps for Work accounts. - pub fn deleted(mut self, new_value: bool) -> UserMessageImportCall<'a, C, NC, A> { + pub fn deleted(mut self, new_value: bool) -> UserMessageImportCall<'a, C, A> { self._deleted = Some(new_value); self } @@ -1881,7 +1877,7 @@ impl<'a, C, NC, A> UserMessageImportCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserMessageImportCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserMessageImportCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1902,7 +1898,7 @@ impl<'a, C, NC, A> UserMessageImportCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserMessageImportCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserMessageImportCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1919,7 +1915,7 @@ impl<'a, C, NC, A> UserMessageImportCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserMessageImportCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserMessageImportCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1961,10 +1957,10 @@ impl<'a, C, NC, A> UserMessageImportCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct UserHistoryListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserHistoryListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _user_id: String, _start_history_id: Option, _page_token: Option, @@ -1975,9 +1971,9 @@ pub struct UserHistoryListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserHistoryListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserHistoryListCall<'a, C, A> {} -impl<'a, C, NC, A> UserHistoryListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserHistoryListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2121,7 +2117,7 @@ impl<'a, C, NC, A> UserHistoryListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserHistoryListCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserHistoryListCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -2129,7 +2125,7 @@ impl<'a, C, NC, A> UserHistoryListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Required. Returns history records after the specified startHistoryId. The supplied startHistoryId should be obtained from the historyId of a message, thread, or previous list response. History IDs increase chronologically but are not contiguous with random gaps in between valid IDs. Supplying an invalid or out of date startHistoryId typically returns an HTTP 404 error code. A historyId is typically valid for at least a week, but in some circumstances may be valid for only a few hours. If you receive an HTTP 404 error response, your application should perform a full sync. If you receive no nextPageToken in the response, there are no updates to retrieve and you can store the returned historyId for a future request. - pub fn start_history_id(mut self, new_value: &str) -> UserHistoryListCall<'a, C, NC, A> { + pub fn start_history_id(mut self, new_value: &str) -> UserHistoryListCall<'a, C, A> { self._start_history_id = Some(new_value.to_string()); self } @@ -2137,7 +2133,7 @@ impl<'a, C, NC, A> UserHistoryListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Page token to retrieve a specific page of results in the list. - pub fn page_token(mut self, new_value: &str) -> UserHistoryListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> UserHistoryListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2145,7 +2141,7 @@ impl<'a, C, NC, A> UserHistoryListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The maximum number of history records to return. - pub fn max_results(mut self, new_value: u32) -> UserHistoryListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> UserHistoryListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2153,7 +2149,7 @@ impl<'a, C, NC, A> UserHistoryListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Only return messages with a label matching the ID. - pub fn label_id(mut self, new_value: &str) -> UserHistoryListCall<'a, C, NC, A> { + pub fn label_id(mut self, new_value: &str) -> UserHistoryListCall<'a, C, A> { self._label_id = Some(new_value.to_string()); self } @@ -2164,7 +2160,7 @@ impl<'a, C, NC, A> UserHistoryListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserHistoryListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserHistoryListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2185,7 +2181,7 @@ impl<'a, C, NC, A> UserHistoryListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserHistoryListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserHistoryListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2202,7 +2198,7 @@ impl<'a, C, NC, A> UserHistoryListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserHistoryListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserHistoryListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2247,10 +2243,10 @@ impl<'a, C, NC, A> UserHistoryListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .upload(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct UserDraftCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserDraftCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _request: Draft, _user_id: String, _delegate: Option<&'a mut Delegate>, @@ -2258,9 +2254,9 @@ pub struct UserDraftCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserDraftCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserDraftCreateCall<'a, C, A> {} -impl<'a, C, NC, A> UserDraftCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserDraftCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2513,7 +2509,7 @@ impl<'a, C, NC, A> UserDraftCreateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Draft) -> UserDraftCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Draft) -> UserDraftCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2523,7 +2519,7 @@ impl<'a, C, NC, A> UserDraftCreateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserDraftCreateCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserDraftCreateCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -2534,7 +2530,7 @@ impl<'a, C, NC, A> UserDraftCreateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDraftCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDraftCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2555,7 +2551,7 @@ impl<'a, C, NC, A> UserDraftCreateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserDraftCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserDraftCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2572,7 +2568,7 @@ impl<'a, C, NC, A> UserDraftCreateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserDraftCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserDraftCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2616,10 +2612,10 @@ impl<'a, C, NC, A> UserDraftCreateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct UserLabelCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserLabelCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _request: Label, _user_id: String, _delegate: Option<&'a mut Delegate>, @@ -2627,9 +2623,9 @@ pub struct UserLabelCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserLabelCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserLabelCreateCall<'a, C, A> {} -impl<'a, C, NC, A> UserLabelCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserLabelCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2768,7 +2764,7 @@ impl<'a, C, NC, A> UserLabelCreateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Label) -> UserLabelCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Label) -> UserLabelCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2778,7 +2774,7 @@ impl<'a, C, NC, A> UserLabelCreateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserLabelCreateCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserLabelCreateCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -2789,7 +2785,7 @@ impl<'a, C, NC, A> UserLabelCreateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserLabelCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserLabelCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2810,7 +2806,7 @@ impl<'a, C, NC, A> UserLabelCreateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserLabelCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserLabelCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2827,7 +2823,7 @@ impl<'a, C, NC, A> UserLabelCreateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserLabelCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserLabelCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2865,10 +2861,10 @@ impl<'a, C, NC, A> UserLabelCreateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct UserLabelDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserLabelDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _user_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -2876,9 +2872,9 @@ pub struct UserLabelDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserLabelDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserLabelDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> UserLabelDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserLabelDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3000,7 +2996,7 @@ impl<'a, C, NC, A> UserLabelDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserLabelDeleteCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserLabelDeleteCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -3010,7 +3006,7 @@ impl<'a, C, NC, A> UserLabelDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the label to delete. - pub fn id(mut self, new_value: &str) -> UserLabelDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> UserLabelDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -3021,7 +3017,7 @@ impl<'a, C, NC, A> UserLabelDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserLabelDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserLabelDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3042,7 +3038,7 @@ impl<'a, C, NC, A> UserLabelDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserLabelDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserLabelDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3059,7 +3055,7 @@ impl<'a, C, NC, A> UserLabelDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserLabelDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserLabelDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3097,10 +3093,10 @@ impl<'a, C, NC, A> UserLabelDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct UserLabelGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserLabelGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _user_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -3108,9 +3104,9 @@ pub struct UserLabelGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserLabelGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserLabelGetCall<'a, C, A> {} -impl<'a, C, NC, A> UserLabelGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserLabelGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3243,7 +3239,7 @@ impl<'a, C, NC, A> UserLabelGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserLabelGetCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserLabelGetCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -3253,7 +3249,7 @@ impl<'a, C, NC, A> UserLabelGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the label to retrieve. - pub fn id(mut self, new_value: &str) -> UserLabelGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> UserLabelGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -3264,7 +3260,7 @@ impl<'a, C, NC, A> UserLabelGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserLabelGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserLabelGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3285,7 +3281,7 @@ impl<'a, C, NC, A> UserLabelGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserLabelGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserLabelGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3302,7 +3298,7 @@ impl<'a, C, NC, A> UserLabelGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserLabelGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserLabelGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3340,10 +3336,10 @@ impl<'a, C, NC, A> UserLabelGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct UserMessageTrashCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserMessageTrashCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _user_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -3351,9 +3347,9 @@ pub struct UserMessageTrashCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserMessageTrashCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserMessageTrashCall<'a, C, A> {} -impl<'a, C, NC, A> UserMessageTrashCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserMessageTrashCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3486,7 +3482,7 @@ impl<'a, C, NC, A> UserMessageTrashCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserMessageTrashCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserMessageTrashCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -3496,7 +3492,7 @@ impl<'a, C, NC, A> UserMessageTrashCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID of the message to Trash. - pub fn id(mut self, new_value: &str) -> UserMessageTrashCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> UserMessageTrashCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -3507,7 +3503,7 @@ impl<'a, C, NC, A> UserMessageTrashCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserMessageTrashCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserMessageTrashCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3528,7 +3524,7 @@ impl<'a, C, NC, A> UserMessageTrashCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserMessageTrashCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserMessageTrashCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3545,7 +3541,7 @@ impl<'a, C, NC, A> UserMessageTrashCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserMessageTrashCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserMessageTrashCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3590,10 +3586,10 @@ impl<'a, C, NC, A> UserMessageTrashCall<'a, C, NC, A> where NC: hyper::net::Netw /// .upload(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct UserDraftSendCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserDraftSendCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _request: Draft, _user_id: String, _delegate: Option<&'a mut Delegate>, @@ -3601,9 +3597,9 @@ pub struct UserDraftSendCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserDraftSendCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserDraftSendCall<'a, C, A> {} -impl<'a, C, NC, A> UserDraftSendCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserDraftSendCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3856,7 +3852,7 @@ impl<'a, C, NC, A> UserDraftSendCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Draft) -> UserDraftSendCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Draft) -> UserDraftSendCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3866,7 +3862,7 @@ impl<'a, C, NC, A> UserDraftSendCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserDraftSendCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserDraftSendCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -3877,7 +3873,7 @@ impl<'a, C, NC, A> UserDraftSendCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDraftSendCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDraftSendCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3898,7 +3894,7 @@ impl<'a, C, NC, A> UserDraftSendCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserDraftSendCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserDraftSendCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3915,7 +3911,7 @@ impl<'a, C, NC, A> UserDraftSendCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserDraftSendCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserDraftSendCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3953,10 +3949,10 @@ impl<'a, C, NC, A> UserDraftSendCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct UserMessageUntrashCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserMessageUntrashCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _user_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -3964,9 +3960,9 @@ pub struct UserMessageUntrashCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserMessageUntrashCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserMessageUntrashCall<'a, C, A> {} -impl<'a, C, NC, A> UserMessageUntrashCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserMessageUntrashCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4099,7 +4095,7 @@ impl<'a, C, NC, A> UserMessageUntrashCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserMessageUntrashCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserMessageUntrashCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -4109,7 +4105,7 @@ impl<'a, C, NC, A> UserMessageUntrashCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The ID of the message to remove from Trash. - pub fn id(mut self, new_value: &str) -> UserMessageUntrashCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> UserMessageUntrashCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -4120,7 +4116,7 @@ impl<'a, C, NC, A> UserMessageUntrashCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserMessageUntrashCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserMessageUntrashCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4141,7 +4137,7 @@ impl<'a, C, NC, A> UserMessageUntrashCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserMessageUntrashCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserMessageUntrashCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4158,7 +4154,7 @@ impl<'a, C, NC, A> UserMessageUntrashCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserMessageUntrashCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserMessageUntrashCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4196,19 +4192,19 @@ impl<'a, C, NC, A> UserMessageUntrashCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct UserLabelListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserLabelListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _user_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserLabelListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserLabelListCall<'a, C, A> {} -impl<'a, C, NC, A> UserLabelListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserLabelListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4340,7 +4336,7 @@ impl<'a, C, NC, A> UserLabelListCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserLabelListCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserLabelListCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -4351,7 +4347,7 @@ impl<'a, C, NC, A> UserLabelListCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserLabelListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserLabelListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4372,7 +4368,7 @@ impl<'a, C, NC, A> UserLabelListCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserLabelListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserLabelListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4389,7 +4385,7 @@ impl<'a, C, NC, A> UserLabelListCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserLabelListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserLabelListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4427,10 +4423,10 @@ impl<'a, C, NC, A> UserLabelListCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct UserMessageDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserMessageDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _user_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -4438,9 +4434,9 @@ pub struct UserMessageDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserMessageDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserMessageDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> UserMessageDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserMessageDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4562,7 +4558,7 @@ impl<'a, C, NC, A> UserMessageDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserMessageDeleteCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserMessageDeleteCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -4572,7 +4568,7 @@ impl<'a, C, NC, A> UserMessageDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the message to delete. - pub fn id(mut self, new_value: &str) -> UserMessageDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> UserMessageDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -4583,7 +4579,7 @@ impl<'a, C, NC, A> UserMessageDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserMessageDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserMessageDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4604,7 +4600,7 @@ impl<'a, C, NC, A> UserMessageDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserMessageDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserMessageDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4621,7 +4617,7 @@ impl<'a, C, NC, A> UserMessageDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserMessageDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserMessageDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4666,10 +4662,10 @@ impl<'a, C, NC, A> UserMessageDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// .upload(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct UserDraftUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserDraftUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _request: Draft, _user_id: String, _id: String, @@ -4678,9 +4674,9 @@ pub struct UserDraftUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserDraftUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserDraftUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> UserDraftUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserDraftUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4934,7 +4930,7 @@ impl<'a, C, NC, A> UserDraftUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Draft) -> UserDraftUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Draft) -> UserDraftUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4944,7 +4940,7 @@ impl<'a, C, NC, A> UserDraftUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserDraftUpdateCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserDraftUpdateCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -4954,7 +4950,7 @@ impl<'a, C, NC, A> UserDraftUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the draft to update. - pub fn id(mut self, new_value: &str) -> UserDraftUpdateCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> UserDraftUpdateCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -4965,7 +4961,7 @@ impl<'a, C, NC, A> UserDraftUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDraftUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDraftUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4986,7 +4982,7 @@ impl<'a, C, NC, A> UserDraftUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserDraftUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserDraftUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5003,7 +4999,7 @@ impl<'a, C, NC, A> UserDraftUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserDraftUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserDraftUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5042,10 +5038,10 @@ impl<'a, C, NC, A> UserDraftUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct UserDraftGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserDraftGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _user_id: String, _id: String, _format: Option, @@ -5054,9 +5050,9 @@ pub struct UserDraftGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserDraftGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserDraftGetCall<'a, C, A> {} -impl<'a, C, NC, A> UserDraftGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserDraftGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5192,7 +5188,7 @@ impl<'a, C, NC, A> UserDraftGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserDraftGetCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserDraftGetCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -5202,7 +5198,7 @@ impl<'a, C, NC, A> UserDraftGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the draft to retrieve. - pub fn id(mut self, new_value: &str) -> UserDraftGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> UserDraftGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -5210,7 +5206,7 @@ impl<'a, C, NC, A> UserDraftGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The format to return the draft in. - pub fn format(mut self, new_value: &str) -> UserDraftGetCall<'a, C, NC, A> { + pub fn format(mut self, new_value: &str) -> UserDraftGetCall<'a, C, A> { self._format = Some(new_value.to_string()); self } @@ -5221,7 +5217,7 @@ impl<'a, C, NC, A> UserDraftGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDraftGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDraftGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5242,7 +5238,7 @@ impl<'a, C, NC, A> UserDraftGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserDraftGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserDraftGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5259,7 +5255,7 @@ impl<'a, C, NC, A> UserDraftGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserDraftGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserDraftGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5303,10 +5299,10 @@ impl<'a, C, NC, A> UserDraftGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct UserLabelUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserLabelUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _request: Label, _user_id: String, _id: String, @@ -5315,9 +5311,9 @@ pub struct UserLabelUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserLabelUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserLabelUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> UserLabelUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserLabelUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5457,7 +5453,7 @@ impl<'a, C, NC, A> UserLabelUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Label) -> UserLabelUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Label) -> UserLabelUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5467,7 +5463,7 @@ impl<'a, C, NC, A> UserLabelUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserLabelUpdateCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserLabelUpdateCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -5477,7 +5473,7 @@ impl<'a, C, NC, A> UserLabelUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the label to update. - pub fn id(mut self, new_value: &str) -> UserLabelUpdateCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> UserLabelUpdateCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -5488,7 +5484,7 @@ impl<'a, C, NC, A> UserLabelUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserLabelUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserLabelUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5509,7 +5505,7 @@ impl<'a, C, NC, A> UserLabelUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserLabelUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserLabelUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5526,7 +5522,7 @@ impl<'a, C, NC, A> UserLabelUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserLabelUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserLabelUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5564,10 +5560,10 @@ impl<'a, C, NC, A> UserLabelUpdateCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct UserThreadUntrashCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserThreadUntrashCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _user_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -5575,9 +5571,9 @@ pub struct UserThreadUntrashCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserThreadUntrashCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserThreadUntrashCall<'a, C, A> {} -impl<'a, C, NC, A> UserThreadUntrashCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserThreadUntrashCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5710,7 +5706,7 @@ impl<'a, C, NC, A> UserThreadUntrashCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserThreadUntrashCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserThreadUntrashCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -5720,7 +5716,7 @@ impl<'a, C, NC, A> UserThreadUntrashCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the thread to remove from Trash. - pub fn id(mut self, new_value: &str) -> UserThreadUntrashCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> UserThreadUntrashCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -5731,7 +5727,7 @@ impl<'a, C, NC, A> UserThreadUntrashCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserThreadUntrashCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserThreadUntrashCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5752,7 +5748,7 @@ impl<'a, C, NC, A> UserThreadUntrashCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserThreadUntrashCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserThreadUntrashCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5769,7 +5765,7 @@ impl<'a, C, NC, A> UserThreadUntrashCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserThreadUntrashCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserThreadUntrashCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5813,10 +5809,10 @@ impl<'a, C, NC, A> UserThreadUntrashCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct UserLabelPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserLabelPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _request: Label, _user_id: String, _id: String, @@ -5825,9 +5821,9 @@ pub struct UserLabelPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserLabelPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserLabelPatchCall<'a, C, A> {} -impl<'a, C, NC, A> UserLabelPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserLabelPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5967,7 +5963,7 @@ impl<'a, C, NC, A> UserLabelPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Label) -> UserLabelPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Label) -> UserLabelPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5977,7 +5973,7 @@ impl<'a, C, NC, A> UserLabelPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserLabelPatchCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserLabelPatchCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -5987,7 +5983,7 @@ impl<'a, C, NC, A> UserLabelPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the label to update. - pub fn id(mut self, new_value: &str) -> UserLabelPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> UserLabelPatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -5998,7 +5994,7 @@ impl<'a, C, NC, A> UserLabelPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserLabelPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserLabelPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6019,7 +6015,7 @@ impl<'a, C, NC, A> UserLabelPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserLabelPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserLabelPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6036,7 +6032,7 @@ impl<'a, C, NC, A> UserLabelPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserLabelPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserLabelPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6074,10 +6070,10 @@ impl<'a, C, NC, A> UserLabelPatchCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct UserDraftDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserDraftDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _user_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -6085,9 +6081,9 @@ pub struct UserDraftDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserDraftDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserDraftDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> UserDraftDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserDraftDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6209,7 +6205,7 @@ impl<'a, C, NC, A> UserDraftDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserDraftDeleteCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserDraftDeleteCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -6219,7 +6215,7 @@ impl<'a, C, NC, A> UserDraftDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the draft to delete. - pub fn id(mut self, new_value: &str) -> UserDraftDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> UserDraftDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -6230,7 +6226,7 @@ impl<'a, C, NC, A> UserDraftDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDraftDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDraftDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6251,7 +6247,7 @@ impl<'a, C, NC, A> UserDraftDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserDraftDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserDraftDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6268,7 +6264,7 @@ impl<'a, C, NC, A> UserDraftDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserDraftDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserDraftDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6311,10 +6307,10 @@ impl<'a, C, NC, A> UserDraftDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct UserThreadListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserThreadListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _user_id: String, _q: Option, _page_token: Option, @@ -6326,9 +6322,9 @@ pub struct UserThreadListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserThreadListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserThreadListCall<'a, C, A> {} -impl<'a, C, NC, A> UserThreadListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserThreadListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6479,7 +6475,7 @@ impl<'a, C, NC, A> UserThreadListCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserThreadListCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserThreadListCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -6487,7 +6483,7 @@ impl<'a, C, NC, A> UserThreadListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Only return threads matching the specified query. Supports the same query format as the Gmail search box. For example, "from:someuser@example.com rfc822msgid: is:unread". - pub fn q(mut self, new_value: &str) -> UserThreadListCall<'a, C, NC, A> { + pub fn q(mut self, new_value: &str) -> UserThreadListCall<'a, C, A> { self._q = Some(new_value.to_string()); self } @@ -6495,7 +6491,7 @@ impl<'a, C, NC, A> UserThreadListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Page token to retrieve a specific page of results in the list. - pub fn page_token(mut self, new_value: &str) -> UserThreadListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> UserThreadListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -6503,7 +6499,7 @@ impl<'a, C, NC, A> UserThreadListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Maximum number of threads to return. - pub fn max_results(mut self, new_value: u32) -> UserThreadListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> UserThreadListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -6512,7 +6508,7 @@ impl<'a, C, NC, A> UserThreadListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Only return threads with labels that match all of the specified label IDs. - pub fn add_label_ids(mut self, new_value: &str) -> UserThreadListCall<'a, C, NC, A> { + pub fn add_label_ids(mut self, new_value: &str) -> UserThreadListCall<'a, C, A> { self._label_ids.push(new_value.to_string()); self } @@ -6520,7 +6516,7 @@ impl<'a, C, NC, A> UserThreadListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Include threads from SPAM and TRASH in the results. - pub fn include_spam_trash(mut self, new_value: bool) -> UserThreadListCall<'a, C, NC, A> { + pub fn include_spam_trash(mut self, new_value: bool) -> UserThreadListCall<'a, C, A> { self._include_spam_trash = Some(new_value); self } @@ -6531,7 +6527,7 @@ impl<'a, C, NC, A> UserThreadListCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserThreadListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserThreadListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6552,7 +6548,7 @@ impl<'a, C, NC, A> UserThreadListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserThreadListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserThreadListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6569,7 +6565,7 @@ impl<'a, C, NC, A> UserThreadListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserThreadListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserThreadListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6613,10 +6609,10 @@ impl<'a, C, NC, A> UserThreadListCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct UserThreadModifyCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserThreadModifyCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _request: ModifyThreadRequest, _user_id: String, _id: String, @@ -6625,9 +6621,9 @@ pub struct UserThreadModifyCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserThreadModifyCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserThreadModifyCall<'a, C, A> {} -impl<'a, C, NC, A> UserThreadModifyCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserThreadModifyCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6767,7 +6763,7 @@ impl<'a, C, NC, A> UserThreadModifyCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ModifyThreadRequest) -> UserThreadModifyCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ModifyThreadRequest) -> UserThreadModifyCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6777,7 +6773,7 @@ impl<'a, C, NC, A> UserThreadModifyCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserThreadModifyCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserThreadModifyCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -6787,7 +6783,7 @@ impl<'a, C, NC, A> UserThreadModifyCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID of the thread to modify. - pub fn id(mut self, new_value: &str) -> UserThreadModifyCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> UserThreadModifyCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -6798,7 +6794,7 @@ impl<'a, C, NC, A> UserThreadModifyCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserThreadModifyCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserThreadModifyCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6819,7 +6815,7 @@ impl<'a, C, NC, A> UserThreadModifyCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserThreadModifyCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserThreadModifyCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6836,7 +6832,7 @@ impl<'a, C, NC, A> UserThreadModifyCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserThreadModifyCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserThreadModifyCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6874,10 +6870,10 @@ impl<'a, C, NC, A> UserThreadModifyCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct UserThreadDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserThreadDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _user_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -6885,9 +6881,9 @@ pub struct UserThreadDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserThreadDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserThreadDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> UserThreadDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserThreadDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7009,7 +7005,7 @@ impl<'a, C, NC, A> UserThreadDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserThreadDeleteCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserThreadDeleteCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -7019,7 +7015,7 @@ impl<'a, C, NC, A> UserThreadDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// ID of the Thread to delete. - pub fn id(mut self, new_value: &str) -> UserThreadDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> UserThreadDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -7030,7 +7026,7 @@ impl<'a, C, NC, A> UserThreadDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserThreadDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserThreadDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7051,7 +7047,7 @@ impl<'a, C, NC, A> UserThreadDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserThreadDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserThreadDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7068,7 +7064,7 @@ impl<'a, C, NC, A> UserThreadDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserThreadDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserThreadDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7106,10 +7102,10 @@ impl<'a, C, NC, A> UserThreadDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct UserMessageAttachmentGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserMessageAttachmentGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _user_id: String, _message_id: String, _id: String, @@ -7118,9 +7114,9 @@ pub struct UserMessageAttachmentGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserMessageAttachmentGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserMessageAttachmentGetCall<'a, C, A> {} -impl<'a, C, NC, A> UserMessageAttachmentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserMessageAttachmentGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7254,7 +7250,7 @@ impl<'a, C, NC, A> UserMessageAttachmentGetCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserMessageAttachmentGetCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserMessageAttachmentGetCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -7264,7 +7260,7 @@ impl<'a, C, NC, A> UserMessageAttachmentGetCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The ID of the message containing the attachment. - pub fn message_id(mut self, new_value: &str) -> UserMessageAttachmentGetCall<'a, C, NC, A> { + pub fn message_id(mut self, new_value: &str) -> UserMessageAttachmentGetCall<'a, C, A> { self._message_id = new_value.to_string(); self } @@ -7274,7 +7270,7 @@ impl<'a, C, NC, A> UserMessageAttachmentGetCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The ID of the attachment. - pub fn id(mut self, new_value: &str) -> UserMessageAttachmentGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> UserMessageAttachmentGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -7285,7 +7281,7 @@ impl<'a, C, NC, A> UserMessageAttachmentGetCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserMessageAttachmentGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserMessageAttachmentGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7306,7 +7302,7 @@ impl<'a, C, NC, A> UserMessageAttachmentGetCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserMessageAttachmentGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserMessageAttachmentGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7323,7 +7319,7 @@ impl<'a, C, NC, A> UserMessageAttachmentGetCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserMessageAttachmentGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserMessageAttachmentGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7367,10 +7363,10 @@ impl<'a, C, NC, A> UserMessageAttachmentGetCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct UserMessageModifyCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserMessageModifyCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _request: ModifyMessageRequest, _user_id: String, _id: String, @@ -7379,9 +7375,9 @@ pub struct UserMessageModifyCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserMessageModifyCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserMessageModifyCall<'a, C, A> {} -impl<'a, C, NC, A> UserMessageModifyCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserMessageModifyCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7521,7 +7517,7 @@ impl<'a, C, NC, A> UserMessageModifyCall<'a, C, NC, A> where NC: hyper::net::Net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ModifyMessageRequest) -> UserMessageModifyCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ModifyMessageRequest) -> UserMessageModifyCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7531,7 +7527,7 @@ impl<'a, C, NC, A> UserMessageModifyCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserMessageModifyCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserMessageModifyCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -7541,7 +7537,7 @@ impl<'a, C, NC, A> UserMessageModifyCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the message to modify. - pub fn id(mut self, new_value: &str) -> UserMessageModifyCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> UserMessageModifyCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -7552,7 +7548,7 @@ impl<'a, C, NC, A> UserMessageModifyCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserMessageModifyCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserMessageModifyCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7573,7 +7569,7 @@ impl<'a, C, NC, A> UserMessageModifyCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserMessageModifyCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserMessageModifyCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7590,7 +7586,7 @@ impl<'a, C, NC, A> UserMessageModifyCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserMessageModifyCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserMessageModifyCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7628,10 +7624,10 @@ impl<'a, C, NC, A> UserMessageModifyCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct UserThreadTrashCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserThreadTrashCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _user_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -7639,9 +7635,9 @@ pub struct UserThreadTrashCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserThreadTrashCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserThreadTrashCall<'a, C, A> {} -impl<'a, C, NC, A> UserThreadTrashCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserThreadTrashCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7774,7 +7770,7 @@ impl<'a, C, NC, A> UserThreadTrashCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserThreadTrashCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserThreadTrashCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -7784,7 +7780,7 @@ impl<'a, C, NC, A> UserThreadTrashCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the thread to Trash. - pub fn id(mut self, new_value: &str) -> UserThreadTrashCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> UserThreadTrashCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -7795,7 +7791,7 @@ impl<'a, C, NC, A> UserThreadTrashCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserThreadTrashCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserThreadTrashCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7816,7 +7812,7 @@ impl<'a, C, NC, A> UserThreadTrashCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserThreadTrashCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserThreadTrashCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7833,7 +7829,7 @@ impl<'a, C, NC, A> UserThreadTrashCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserThreadTrashCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserThreadTrashCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7873,10 +7869,10 @@ impl<'a, C, NC, A> UserThreadTrashCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct UserDraftListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserDraftListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _user_id: String, _page_token: Option, _max_results: Option, @@ -7885,9 +7881,9 @@ pub struct UserDraftListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserDraftListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserDraftListCall<'a, C, A> {} -impl<'a, C, NC, A> UserDraftListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserDraftListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8025,7 +8021,7 @@ impl<'a, C, NC, A> UserDraftListCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserDraftListCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserDraftListCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -8033,7 +8029,7 @@ impl<'a, C, NC, A> UserDraftListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Page token to retrieve a specific page of results in the list. - pub fn page_token(mut self, new_value: &str) -> UserDraftListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> UserDraftListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -8041,7 +8037,7 @@ impl<'a, C, NC, A> UserDraftListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Maximum number of drafts to return. - pub fn max_results(mut self, new_value: u32) -> UserDraftListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> UserDraftListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -8052,7 +8048,7 @@ impl<'a, C, NC, A> UserDraftListCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDraftListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDraftListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8073,7 +8069,7 @@ impl<'a, C, NC, A> UserDraftListCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserDraftListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserDraftListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8090,7 +8086,7 @@ impl<'a, C, NC, A> UserDraftListCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserDraftListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserDraftListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8135,10 +8131,10 @@ impl<'a, C, NC, A> UserDraftListCall<'a, C, NC, A> where NC: hyper::net::Network /// .upload(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct UserMessageSendCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserMessageSendCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _request: Message, _user_id: String, _delegate: Option<&'a mut Delegate>, @@ -8146,9 +8142,9 @@ pub struct UserMessageSendCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserMessageSendCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserMessageSendCall<'a, C, A> {} -impl<'a, C, NC, A> UserMessageSendCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserMessageSendCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8401,7 +8397,7 @@ impl<'a, C, NC, A> UserMessageSendCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Message) -> UserMessageSendCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Message) -> UserMessageSendCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8411,7 +8407,7 @@ impl<'a, C, NC, A> UserMessageSendCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserMessageSendCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserMessageSendCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -8422,7 +8418,7 @@ impl<'a, C, NC, A> UserMessageSendCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserMessageSendCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserMessageSendCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8443,7 +8439,7 @@ impl<'a, C, NC, A> UserMessageSendCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserMessageSendCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserMessageSendCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8460,7 +8456,7 @@ impl<'a, C, NC, A> UserMessageSendCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserMessageSendCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserMessageSendCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8500,10 +8496,10 @@ impl<'a, C, NC, A> UserMessageSendCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct UserMessageGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserMessageGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _user_id: String, _id: String, _metadata_headers: Vec, @@ -8513,9 +8509,9 @@ pub struct UserMessageGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserMessageGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserMessageGetCall<'a, C, A> {} -impl<'a, C, NC, A> UserMessageGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserMessageGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8658,7 +8654,7 @@ impl<'a, C, NC, A> UserMessageGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserMessageGetCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserMessageGetCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -8668,7 +8664,7 @@ impl<'a, C, NC, A> UserMessageGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the message to retrieve. - pub fn id(mut self, new_value: &str) -> UserMessageGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> UserMessageGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -8677,7 +8673,7 @@ impl<'a, C, NC, A> UserMessageGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// When given and format is METADATA, only include headers specified. - pub fn add_metadata_headers(mut self, new_value: &str) -> UserMessageGetCall<'a, C, NC, A> { + pub fn add_metadata_headers(mut self, new_value: &str) -> UserMessageGetCall<'a, C, A> { self._metadata_headers.push(new_value.to_string()); self } @@ -8685,7 +8681,7 @@ impl<'a, C, NC, A> UserMessageGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The format to return the message in. - pub fn format(mut self, new_value: &str) -> UserMessageGetCall<'a, C, NC, A> { + pub fn format(mut self, new_value: &str) -> UserMessageGetCall<'a, C, A> { self._format = Some(new_value.to_string()); self } @@ -8696,7 +8692,7 @@ impl<'a, C, NC, A> UserMessageGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserMessageGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserMessageGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8717,7 +8713,7 @@ impl<'a, C, NC, A> UserMessageGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserMessageGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserMessageGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8734,7 +8730,7 @@ impl<'a, C, NC, A> UserMessageGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserMessageGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserMessageGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8777,10 +8773,10 @@ impl<'a, C, NC, A> UserMessageGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct UserMessageListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserMessageListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _user_id: String, _q: Option, _page_token: Option, @@ -8792,9 +8788,9 @@ pub struct UserMessageListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserMessageListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserMessageListCall<'a, C, A> {} -impl<'a, C, NC, A> UserMessageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserMessageListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8945,7 +8941,7 @@ impl<'a, C, NC, A> UserMessageListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserMessageListCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserMessageListCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -8953,7 +8949,7 @@ impl<'a, C, NC, A> UserMessageListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Only return messages matching the specified query. Supports the same query format as the Gmail search box. For example, "from:someuser@example.com rfc822msgid: is:unread". - pub fn q(mut self, new_value: &str) -> UserMessageListCall<'a, C, NC, A> { + pub fn q(mut self, new_value: &str) -> UserMessageListCall<'a, C, A> { self._q = Some(new_value.to_string()); self } @@ -8961,7 +8957,7 @@ impl<'a, C, NC, A> UserMessageListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Page token to retrieve a specific page of results in the list. - pub fn page_token(mut self, new_value: &str) -> UserMessageListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> UserMessageListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -8969,7 +8965,7 @@ impl<'a, C, NC, A> UserMessageListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Maximum number of messages to return. - pub fn max_results(mut self, new_value: u32) -> UserMessageListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> UserMessageListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -8978,7 +8974,7 @@ impl<'a, C, NC, A> UserMessageListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Only return messages with labels that match all of the specified label IDs. - pub fn add_label_ids(mut self, new_value: &str) -> UserMessageListCall<'a, C, NC, A> { + pub fn add_label_ids(mut self, new_value: &str) -> UserMessageListCall<'a, C, A> { self._label_ids.push(new_value.to_string()); self } @@ -8986,7 +8982,7 @@ impl<'a, C, NC, A> UserMessageListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Include messages from SPAM and TRASH in the results. - pub fn include_spam_trash(mut self, new_value: bool) -> UserMessageListCall<'a, C, NC, A> { + pub fn include_spam_trash(mut self, new_value: bool) -> UserMessageListCall<'a, C, A> { self._include_spam_trash = Some(new_value); self } @@ -8997,7 +8993,7 @@ impl<'a, C, NC, A> UserMessageListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserMessageListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserMessageListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9018,7 +9014,7 @@ impl<'a, C, NC, A> UserMessageListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserMessageListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserMessageListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9035,7 +9031,7 @@ impl<'a, C, NC, A> UserMessageListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserMessageListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserMessageListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9073,19 +9069,19 @@ impl<'a, C, NC, A> UserMessageListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct UserGetProfileCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserGetProfileCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _user_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserGetProfileCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserGetProfileCall<'a, C, A> {} -impl<'a, C, NC, A> UserGetProfileCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserGetProfileCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9217,7 +9213,7 @@ impl<'a, C, NC, A> UserGetProfileCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserGetProfileCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserGetProfileCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -9228,7 +9224,7 @@ impl<'a, C, NC, A> UserGetProfileCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserGetProfileCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserGetProfileCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9249,7 +9245,7 @@ impl<'a, C, NC, A> UserGetProfileCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserGetProfileCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserGetProfileCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9266,7 +9262,7 @@ impl<'a, C, NC, A> UserGetProfileCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserGetProfileCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserGetProfileCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9306,10 +9302,10 @@ impl<'a, C, NC, A> UserGetProfileCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct UserThreadGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserThreadGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _user_id: String, _id: String, _metadata_headers: Vec, @@ -9319,9 +9315,9 @@ pub struct UserThreadGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserThreadGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserThreadGetCall<'a, C, A> {} -impl<'a, C, NC, A> UserThreadGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserThreadGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9464,7 +9460,7 @@ impl<'a, C, NC, A> UserThreadGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserThreadGetCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserThreadGetCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -9474,7 +9470,7 @@ impl<'a, C, NC, A> UserThreadGetCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the thread to retrieve. - pub fn id(mut self, new_value: &str) -> UserThreadGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> UserThreadGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -9483,7 +9479,7 @@ impl<'a, C, NC, A> UserThreadGetCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// When given and format is METADATA, only include headers specified. - pub fn add_metadata_headers(mut self, new_value: &str) -> UserThreadGetCall<'a, C, NC, A> { + pub fn add_metadata_headers(mut self, new_value: &str) -> UserThreadGetCall<'a, C, A> { self._metadata_headers.push(new_value.to_string()); self } @@ -9491,7 +9487,7 @@ impl<'a, C, NC, A> UserThreadGetCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// The format to return the messages in. - pub fn format(mut self, new_value: &str) -> UserThreadGetCall<'a, C, NC, A> { + pub fn format(mut self, new_value: &str) -> UserThreadGetCall<'a, C, A> { self._format = Some(new_value.to_string()); self } @@ -9502,7 +9498,7 @@ impl<'a, C, NC, A> UserThreadGetCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserThreadGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserThreadGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9523,7 +9519,7 @@ impl<'a, C, NC, A> UserThreadGetCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserThreadGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserThreadGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9540,7 +9536,7 @@ impl<'a, C, NC, A> UserThreadGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserThreadGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserThreadGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9587,10 +9583,10 @@ impl<'a, C, NC, A> UserThreadGetCall<'a, C, NC, A> where NC: hyper::net::Network /// .upload(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct UserMessageInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserMessageInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Gmail, + hub: &'a Gmail, _request: Message, _user_id: String, _internal_date_source: Option, @@ -9600,9 +9596,9 @@ pub struct UserMessageInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserMessageInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserMessageInsertCall<'a, C, A> {} -impl<'a, C, NC, A> UserMessageInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserMessageInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9861,7 +9857,7 @@ impl<'a, C, NC, A> UserMessageInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Message) -> UserMessageInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Message) -> UserMessageInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9871,7 +9867,7 @@ impl<'a, C, NC, A> UserMessageInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The user's email address. The special value me can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> UserMessageInsertCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> UserMessageInsertCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -9879,7 +9875,7 @@ impl<'a, C, NC, A> UserMessageInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Source for Gmail's internal date of the message. - pub fn internal_date_source(mut self, new_value: &str) -> UserMessageInsertCall<'a, C, NC, A> { + pub fn internal_date_source(mut self, new_value: &str) -> UserMessageInsertCall<'a, C, A> { self._internal_date_source = Some(new_value.to_string()); self } @@ -9887,7 +9883,7 @@ impl<'a, C, NC, A> UserMessageInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Mark the email as permanently deleted (not TRASH) and only visible in Google Apps Vault to a Vault administrator. Only used for Google Apps for Work accounts. - pub fn deleted(mut self, new_value: bool) -> UserMessageInsertCall<'a, C, NC, A> { + pub fn deleted(mut self, new_value: bool) -> UserMessageInsertCall<'a, C, A> { self._deleted = Some(new_value); self } @@ -9898,7 +9894,7 @@ impl<'a, C, NC, A> UserMessageInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserMessageInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserMessageInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9919,7 +9915,7 @@ impl<'a, C, NC, A> UserMessageInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserMessageInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserMessageInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9936,7 +9932,7 @@ impl<'a, C, NC, A> UserMessageInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserMessageInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserMessageInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/groupsmigration1/Cargo.toml b/gen/groupsmigration1/Cargo.toml index 0d84547cf86..dae14cbe34a 100644 --- a/gen/groupsmigration1/Cargo.toml +++ b/gen/groupsmigration1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-groupsmigration1" -version = "0.1.4+20140416" +version = "0.1.5+20140416" authors = ["Sebastian Thiel "] description = "A complete library to interact with Groups Migration (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/groupsmigration1" homepage = "https://developers.google.com/google-apps/groups-migration/" -documentation = "http://byron.github.io/google-apis-rs/google-groupsmigration1" +documentation = "http://byron.github.io/google-apis-rs/google_groupsmigration1" license = "MIT" keywords = ["groupsmigration", "google", "protocol", "web", "api"] diff --git a/gen/groupsmigration1/README.md b/gen/groupsmigration1/README.md index 9bac90a1845..2c91b13feee 100644 --- a/gen/groupsmigration1/README.md +++ b/gen/groupsmigration1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-groupsmigration1` library allows access to all features of the *Google Groups Migration* service. -This documentation was generated from *Groups Migration* crate version *0.1.4+20140416*, where *20140416* is the exact revision of the *groupsmigration:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *Groups Migration* crate version *0.1.5+20140416*, where *20140416* is the exact revision of the *groupsmigration:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *Groups Migration* *v1* API can be found at the [official documentation site](https://developers.google.com/google-apps/groups-migration/). diff --git a/gen/groupsmigration1/src/cmn.rs b/gen/groupsmigration1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/groupsmigration1/src/cmn.rs +++ b/gen/groupsmigration1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/groupsmigration1/src/lib.rs b/gen/groupsmigration1/src/lib.rs index ea36b62a5a2..82ddd7151c7 100644 --- a/gen/groupsmigration1/src/lib.rs +++ b/gen/groupsmigration1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *Groups Migration* crate version *0.1.4+20140416*, where *20140416* is the exact revision of the *groupsmigration:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *Groups Migration* crate version *0.1.5+20140416*, where *20140416* is the exact revision of the *groupsmigration:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *Groups Migration* *v1* API can be found at the //! [official documentation site](https://developers.google.com/google-apps/groups-migration/). @@ -193,7 +193,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -285,34 +284,31 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct GroupsMigration { +pub struct GroupsMigration { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for GroupsMigration {} +impl<'a, C, A> Hub for GroupsMigration {} -impl<'a, C, NC, A> GroupsMigration - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GroupsMigration + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> GroupsMigration { + pub fn new(client: C, authenticator: A) -> GroupsMigration { GroupsMigration { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn archive(&'a self) -> ArchiveMethods<'a, C, NC, A> { + pub fn archive(&'a self) -> ArchiveMethods<'a, C, A> { ArchiveMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -380,15 +376,15 @@ impl ResponseResult for Groups {} /// let rb = hub.archive(); /// # } /// ``` -pub struct ArchiveMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ArchiveMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GroupsMigration, + hub: &'a GroupsMigration, } -impl<'a, C, NC, A> MethodsBuilder for ArchiveMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ArchiveMethods<'a, C, A> {} -impl<'a, C, NC, A> ArchiveMethods<'a, C, NC, A> { +impl<'a, C, A> ArchiveMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -397,7 +393,7 @@ impl<'a, C, NC, A> ArchiveMethods<'a, C, NC, A> { /// # Arguments /// /// * `groupId` - The group ID - pub fn insert(&self, group_id: &str) -> ArchiveInsertCall<'a, C, NC, A> { + pub fn insert(&self, group_id: &str) -> ArchiveInsertCall<'a, C, A> { ArchiveInsertCall { hub: self.hub, _group_id: group_id.to_string(), @@ -447,19 +443,19 @@ impl<'a, C, NC, A> ArchiveMethods<'a, C, NC, A> { /// .upload(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct ArchiveInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ArchiveInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a GroupsMigration, + hub: &'a GroupsMigration, _group_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ArchiveInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ArchiveInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ArchiveInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ArchiveInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -700,7 +696,7 @@ impl<'a, C, NC, A> ArchiveInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The group ID - pub fn group_id(mut self, new_value: &str) -> ArchiveInsertCall<'a, C, NC, A> { + pub fn group_id(mut self, new_value: &str) -> ArchiveInsertCall<'a, C, A> { self._group_id = new_value.to_string(); self } @@ -711,7 +707,7 @@ impl<'a, C, NC, A> ArchiveInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ArchiveInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ArchiveInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -732,7 +728,7 @@ impl<'a, C, NC, A> ArchiveInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ArchiveInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ArchiveInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -749,7 +745,7 @@ impl<'a, C, NC, A> ArchiveInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ArchiveInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ArchiveInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/groupssettings1/Cargo.toml b/gen/groupssettings1/Cargo.toml index 43fe067b14e..02a9746054b 100644 --- a/gen/groupssettings1/Cargo.toml +++ b/gen/groupssettings1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-groupssettings1" -version = "0.1.4+20140428" +version = "0.1.5+20140428" authors = ["Sebastian Thiel "] description = "A complete library to interact with groupssettings (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/groupssettings1" homepage = "https://developers.google.com/google-apps/groups-settings/get_started" -documentation = "http://byron.github.io/google-apis-rs/google-groupssettings1" +documentation = "http://byron.github.io/google-apis-rs/google_groupssettings1" license = "MIT" keywords = ["groupssettings", "google", "protocol", "web", "api"] diff --git a/gen/groupssettings1/README.md b/gen/groupssettings1/README.md index 1b40f55a8fb..a9ececadd04 100644 --- a/gen/groupssettings1/README.md +++ b/gen/groupssettings1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-groupssettings1` library allows access to all features of the *Google groupssettings* service. -This documentation was generated from *groupssettings* crate version *0.1.4+20140428*, where *20140428* is the exact revision of the *groupssettings:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *groupssettings* crate version *0.1.5+20140428*, where *20140428* is the exact revision of the *groupssettings:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *groupssettings* *v1* API can be found at the [official documentation site](https://developers.google.com/google-apps/groups-settings/get_started). diff --git a/gen/groupssettings1/src/cmn.rs b/gen/groupssettings1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/groupssettings1/src/cmn.rs +++ b/gen/groupssettings1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/groupssettings1/src/lib.rs b/gen/groupssettings1/src/lib.rs index d14ce0cd7c0..92cc2f2f08f 100644 --- a/gen/groupssettings1/src/lib.rs +++ b/gen/groupssettings1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *groupssettings* crate version *0.1.4+20140428*, where *20140428* is the exact revision of the *groupssettings:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *groupssettings* crate version *0.1.5+20140428*, where *20140428* is the exact revision of the *groupssettings:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *groupssettings* *v1* API can be found at the //! [official documentation site](https://developers.google.com/google-apps/groups-settings/get_started). @@ -196,7 +196,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -293,34 +292,31 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Groupssettings { +pub struct Groupssettings { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Groupssettings {} +impl<'a, C, A> Hub for Groupssettings {} -impl<'a, C, NC, A> Groupssettings - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Groupssettings + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Groupssettings { + pub fn new(client: C, authenticator: A) -> Groupssettings { Groupssettings { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn groups(&'a self) -> GroupMethods<'a, C, NC, A> { + pub fn groups(&'a self) -> GroupMethods<'a, C, A> { GroupMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -466,15 +462,15 @@ impl ResponseResult for Groups {} /// let rb = hub.groups(); /// # } /// ``` -pub struct GroupMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GroupMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Groupssettings, + hub: &'a Groupssettings, } -impl<'a, C, NC, A> MethodsBuilder for GroupMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for GroupMethods<'a, C, A> {} -impl<'a, C, NC, A> GroupMethods<'a, C, NC, A> { +impl<'a, C, A> GroupMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -484,7 +480,7 @@ impl<'a, C, NC, A> GroupMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `groupUniqueId` - The resource ID - pub fn update(&self, request: &Groups, group_unique_id: &str) -> GroupUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Groups, group_unique_id: &str) -> GroupUpdateCall<'a, C, A> { GroupUpdateCall { hub: self.hub, _request: request.clone(), @@ -503,7 +499,7 @@ impl<'a, C, NC, A> GroupMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `groupUniqueId` - The resource ID - pub fn patch(&self, request: &Groups, group_unique_id: &str) -> GroupPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Groups, group_unique_id: &str) -> GroupPatchCall<'a, C, A> { GroupPatchCall { hub: self.hub, _request: request.clone(), @@ -521,7 +517,7 @@ impl<'a, C, NC, A> GroupMethods<'a, C, NC, A> { /// # Arguments /// /// * `groupUniqueId` - The resource ID - pub fn get(&self, group_unique_id: &str) -> GroupGetCall<'a, C, NC, A> { + pub fn get(&self, group_unique_id: &str) -> GroupGetCall<'a, C, A> { GroupGetCall { hub: self.hub, _group_unique_id: group_unique_id.to_string(), @@ -576,10 +572,10 @@ impl<'a, C, NC, A> GroupMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct GroupUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GroupUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Groupssettings, + hub: &'a Groupssettings, _request: Groups, _group_unique_id: String, _delegate: Option<&'a mut Delegate>, @@ -587,9 +583,9 @@ pub struct GroupUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GroupUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GroupUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> GroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GroupUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -728,7 +724,7 @@ impl<'a, C, NC, A> GroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Groups) -> GroupUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Groups) -> GroupUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -738,7 +734,7 @@ impl<'a, C, NC, A> GroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The resource ID - pub fn group_unique_id(mut self, new_value: &str) -> GroupUpdateCall<'a, C, NC, A> { + pub fn group_unique_id(mut self, new_value: &str) -> GroupUpdateCall<'a, C, A> { self._group_unique_id = new_value.to_string(); self } @@ -749,7 +745,7 @@ impl<'a, C, NC, A> GroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -770,7 +766,7 @@ impl<'a, C, NC, A> GroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GroupUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GroupUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -787,7 +783,7 @@ impl<'a, C, NC, A> GroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GroupUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GroupUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -831,10 +827,10 @@ impl<'a, C, NC, A> GroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct GroupPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GroupPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Groupssettings, + hub: &'a Groupssettings, _request: Groups, _group_unique_id: String, _delegate: Option<&'a mut Delegate>, @@ -842,9 +838,9 @@ pub struct GroupPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GroupPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GroupPatchCall<'a, C, A> {} -impl<'a, C, NC, A> GroupPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GroupPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -983,7 +979,7 @@ impl<'a, C, NC, A> GroupPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Groups) -> GroupPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Groups) -> GroupPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -993,7 +989,7 @@ impl<'a, C, NC, A> GroupPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The resource ID - pub fn group_unique_id(mut self, new_value: &str) -> GroupPatchCall<'a, C, NC, A> { + pub fn group_unique_id(mut self, new_value: &str) -> GroupPatchCall<'a, C, A> { self._group_unique_id = new_value.to_string(); self } @@ -1004,7 +1000,7 @@ impl<'a, C, NC, A> GroupPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1025,7 +1021,7 @@ impl<'a, C, NC, A> GroupPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GroupPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GroupPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1042,7 +1038,7 @@ impl<'a, C, NC, A> GroupPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GroupPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GroupPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1080,19 +1076,19 @@ impl<'a, C, NC, A> GroupPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct GroupGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GroupGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Groupssettings, + hub: &'a Groupssettings, _group_unique_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GroupGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GroupGetCall<'a, C, A> {} -impl<'a, C, NC, A> GroupGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GroupGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1224,7 +1220,7 @@ impl<'a, C, NC, A> GroupGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The resource ID - pub fn group_unique_id(mut self, new_value: &str) -> GroupGetCall<'a, C, NC, A> { + pub fn group_unique_id(mut self, new_value: &str) -> GroupGetCall<'a, C, A> { self._group_unique_id = new_value.to_string(); self } @@ -1235,7 +1231,7 @@ impl<'a, C, NC, A> GroupGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1256,7 +1252,7 @@ impl<'a, C, NC, A> GroupGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GroupGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GroupGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1273,7 +1269,7 @@ impl<'a, C, NC, A> GroupGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GroupGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GroupGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/identitytoolkit3/Cargo.toml b/gen/identitytoolkit3/Cargo.toml index b470444504b..a262cc0600d 100644 --- a/gen/identitytoolkit3/Cargo.toml +++ b/gen/identitytoolkit3/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-identitytoolkit3" -version = "0.1.4+20141009" +version = "0.1.5+20141009" authors = ["Sebastian Thiel "] description = "A complete library to interact with Identity Toolkit (protocol v3)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/identitytoolkit3" homepage = "https://developers.google.com/identity-toolkit/v3/" -documentation = "http://byron.github.io/google-apis-rs/google-identitytoolkit3" +documentation = "http://byron.github.io/google-apis-rs/google_identitytoolkit3" license = "MIT" keywords = ["identitytoolkit", "google", "protocol", "web", "api"] diff --git a/gen/identitytoolkit3/README.md b/gen/identitytoolkit3/README.md index 5a73f3e6d09..3b6463a4146 100644 --- a/gen/identitytoolkit3/README.md +++ b/gen/identitytoolkit3/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-identitytoolkit3` library allows access to all features of the *Google Identity Toolkit* service. -This documentation was generated from *Identity Toolkit* crate version *0.1.4+20141009*, where *20141009* is the exact revision of the *identitytoolkit:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *Identity Toolkit* crate version *0.1.5+20141009*, where *20141009* is the exact revision of the *identitytoolkit:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *Identity Toolkit* *v3* API can be found at the [official documentation site](https://developers.google.com/identity-toolkit/v3/). diff --git a/gen/identitytoolkit3/src/cmn.rs b/gen/identitytoolkit3/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/identitytoolkit3/src/cmn.rs +++ b/gen/identitytoolkit3/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/identitytoolkit3/src/lib.rs b/gen/identitytoolkit3/src/lib.rs index 08642ba8257..cc6d1d4fcf1 100644 --- a/gen/identitytoolkit3/src/lib.rs +++ b/gen/identitytoolkit3/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *Identity Toolkit* crate version *0.1.4+20141009*, where *20141009* is the exact revision of the *identitytoolkit:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *Identity Toolkit* crate version *0.1.5+20141009*, where *20141009* is the exact revision of the *identitytoolkit:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *Identity Toolkit* *v3* API can be found at the //! [official documentation site](https://developers.google.com/identity-toolkit/v3/). @@ -194,7 +194,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -269,34 +268,31 @@ pub use cmn::{MultiPartReader, ToParts, MethodInfo, Result, Error, CallBuilder, /// } /// # } /// ``` -pub struct IdentityToolkit { +pub struct IdentityToolkit { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for IdentityToolkit {} +impl<'a, C, A> Hub for IdentityToolkit {} -impl<'a, C, NC, A> IdentityToolkit - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> IdentityToolkit + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> IdentityToolkit { + pub fn new(client: C, authenticator: A) -> IdentityToolkit { IdentityToolkit { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn relyingparty(&'a self) -> RelyingpartyMethods<'a, C, NC, A> { + pub fn relyingparty(&'a self) -> RelyingpartyMethods<'a, C, A> { RelyingpartyMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -1065,15 +1061,15 @@ impl Part for UserInfo {} /// let rb = hub.relyingparty(); /// # } /// ``` -pub struct RelyingpartyMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RelyingpartyMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a IdentityToolkit, + hub: &'a IdentityToolkit, } -impl<'a, C, NC, A> MethodsBuilder for RelyingpartyMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for RelyingpartyMethods<'a, C, A> {} -impl<'a, C, NC, A> RelyingpartyMethods<'a, C, NC, A> { +impl<'a, C, A> RelyingpartyMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1082,7 +1078,7 @@ impl<'a, C, NC, A> RelyingpartyMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn get_oob_confirmation_code(&self, request: &Relyingparty) -> RelyingpartyGetOobConfirmationCodeCall<'a, C, NC, A> { + pub fn get_oob_confirmation_code(&self, request: &Relyingparty) -> RelyingpartyGetOobConfirmationCodeCall<'a, C, A> { RelyingpartyGetOobConfirmationCodeCall { hub: self.hub, _request: request.clone(), @@ -1094,7 +1090,7 @@ impl<'a, C, NC, A> RelyingpartyMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Get token signing public key. - pub fn get_public_keys(&self) -> RelyingpartyGetPublicKeyCall<'a, C, NC, A> { + pub fn get_public_keys(&self) -> RelyingpartyGetPublicKeyCall<'a, C, A> { RelyingpartyGetPublicKeyCall { hub: self.hub, _delegate: Default::default(), @@ -1109,7 +1105,7 @@ impl<'a, C, NC, A> RelyingpartyMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn create_auth_uri(&self, request: &IdentitytoolkitRelyingpartyCreateAuthUriRequest) -> RelyingpartyCreateAuthUriCall<'a, C, NC, A> { + pub fn create_auth_uri(&self, request: &IdentitytoolkitRelyingpartyCreateAuthUriRequest) -> RelyingpartyCreateAuthUriCall<'a, C, A> { RelyingpartyCreateAuthUriCall { hub: self.hub, _request: request.clone(), @@ -1125,7 +1121,7 @@ impl<'a, C, NC, A> RelyingpartyMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn verify_assertion(&self, request: &IdentitytoolkitRelyingpartyVerifyAssertionRequest) -> RelyingpartyVerifyAssertionCall<'a, C, NC, A> { + pub fn verify_assertion(&self, request: &IdentitytoolkitRelyingpartyVerifyAssertionRequest) -> RelyingpartyVerifyAssertionCall<'a, C, A> { RelyingpartyVerifyAssertionCall { hub: self.hub, _request: request.clone(), @@ -1141,7 +1137,7 @@ impl<'a, C, NC, A> RelyingpartyMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn upload_account(&self, request: &IdentitytoolkitRelyingpartyUploadAccountRequest) -> RelyingpartyUploadAccountCall<'a, C, NC, A> { + pub fn upload_account(&self, request: &IdentitytoolkitRelyingpartyUploadAccountRequest) -> RelyingpartyUploadAccountCall<'a, C, A> { RelyingpartyUploadAccountCall { hub: self.hub, _request: request.clone(), @@ -1157,7 +1153,7 @@ impl<'a, C, NC, A> RelyingpartyMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn get_account_info(&self, request: &IdentitytoolkitRelyingpartyGetAccountInfoRequest) -> RelyingpartyGetAccountInfoCall<'a, C, NC, A> { + pub fn get_account_info(&self, request: &IdentitytoolkitRelyingpartyGetAccountInfoRequest) -> RelyingpartyGetAccountInfoCall<'a, C, A> { RelyingpartyGetAccountInfoCall { hub: self.hub, _request: request.clone(), @@ -1173,7 +1169,7 @@ impl<'a, C, NC, A> RelyingpartyMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn reset_password(&self, request: &IdentitytoolkitRelyingpartyResetPasswordRequest) -> RelyingpartyResetPasswordCall<'a, C, NC, A> { + pub fn reset_password(&self, request: &IdentitytoolkitRelyingpartyResetPasswordRequest) -> RelyingpartyResetPasswordCall<'a, C, A> { RelyingpartyResetPasswordCall { hub: self.hub, _request: request.clone(), @@ -1189,7 +1185,7 @@ impl<'a, C, NC, A> RelyingpartyMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn download_account(&self, request: &IdentitytoolkitRelyingpartyDownloadAccountRequest) -> RelyingpartyDownloadAccountCall<'a, C, NC, A> { + pub fn download_account(&self, request: &IdentitytoolkitRelyingpartyDownloadAccountRequest) -> RelyingpartyDownloadAccountCall<'a, C, A> { RelyingpartyDownloadAccountCall { hub: self.hub, _request: request.clone(), @@ -1205,7 +1201,7 @@ impl<'a, C, NC, A> RelyingpartyMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn set_account_info(&self, request: &IdentitytoolkitRelyingpartySetAccountInfoRequest) -> RelyingpartySetAccountInfoCall<'a, C, NC, A> { + pub fn set_account_info(&self, request: &IdentitytoolkitRelyingpartySetAccountInfoRequest) -> RelyingpartySetAccountInfoCall<'a, C, A> { RelyingpartySetAccountInfoCall { hub: self.hub, _request: request.clone(), @@ -1221,7 +1217,7 @@ impl<'a, C, NC, A> RelyingpartyMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn delete_account(&self, request: &IdentitytoolkitRelyingpartyDeleteAccountRequest) -> RelyingpartyDeleteAccountCall<'a, C, NC, A> { + pub fn delete_account(&self, request: &IdentitytoolkitRelyingpartyDeleteAccountRequest) -> RelyingpartyDeleteAccountCall<'a, C, A> { RelyingpartyDeleteAccountCall { hub: self.hub, _request: request.clone(), @@ -1237,7 +1233,7 @@ impl<'a, C, NC, A> RelyingpartyMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn verify_password(&self, request: &IdentitytoolkitRelyingpartyVerifyPasswordRequest) -> RelyingpartyVerifyPasswordCall<'a, C, NC, A> { + pub fn verify_password(&self, request: &IdentitytoolkitRelyingpartyVerifyPasswordRequest) -> RelyingpartyVerifyPasswordCall<'a, C, A> { RelyingpartyVerifyPasswordCall { hub: self.hub, _request: request.clone(), @@ -1291,18 +1287,18 @@ impl<'a, C, NC, A> RelyingpartyMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct RelyingpartyGetOobConfirmationCodeCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RelyingpartyGetOobConfirmationCodeCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a IdentityToolkit, + hub: &'a IdentityToolkit, _request: Relyingparty, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for RelyingpartyGetOobConfirmationCodeCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RelyingpartyGetOobConfirmationCodeCall<'a, C, A> {} -impl<'a, C, NC, A> RelyingpartyGetOobConfirmationCodeCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RelyingpartyGetOobConfirmationCodeCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1414,7 +1410,7 @@ impl<'a, C, NC, A> RelyingpartyGetOobConfirmationCodeCall<'a, C, NC, A> where NC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Relyingparty) -> RelyingpartyGetOobConfirmationCodeCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Relyingparty) -> RelyingpartyGetOobConfirmationCodeCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1425,7 +1421,7 @@ impl<'a, C, NC, A> RelyingpartyGetOobConfirmationCodeCall<'a, C, NC, A> where NC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RelyingpartyGetOobConfirmationCodeCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RelyingpartyGetOobConfirmationCodeCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1446,7 +1442,7 @@ impl<'a, C, NC, A> RelyingpartyGetOobConfirmationCodeCall<'a, C, NC, A> where NC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RelyingpartyGetOobConfirmationCodeCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RelyingpartyGetOobConfirmationCodeCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1485,17 +1481,17 @@ impl<'a, C, NC, A> RelyingpartyGetOobConfirmationCodeCall<'a, C, NC, A> where NC /// .doit(); /// # } /// ``` -pub struct RelyingpartyGetPublicKeyCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RelyingpartyGetPublicKeyCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a IdentityToolkit, + hub: &'a IdentityToolkit, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for RelyingpartyGetPublicKeyCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RelyingpartyGetPublicKeyCall<'a, C, A> {} -impl<'a, C, NC, A> RelyingpartyGetPublicKeyCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RelyingpartyGetPublicKeyCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1601,7 +1597,7 @@ impl<'a, C, NC, A> RelyingpartyGetPublicKeyCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RelyingpartyGetPublicKeyCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RelyingpartyGetPublicKeyCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1622,7 +1618,7 @@ impl<'a, C, NC, A> RelyingpartyGetPublicKeyCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RelyingpartyGetPublicKeyCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RelyingpartyGetPublicKeyCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1667,18 +1663,18 @@ impl<'a, C, NC, A> RelyingpartyGetPublicKeyCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct RelyingpartyCreateAuthUriCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RelyingpartyCreateAuthUriCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a IdentityToolkit, + hub: &'a IdentityToolkit, _request: IdentitytoolkitRelyingpartyCreateAuthUriRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for RelyingpartyCreateAuthUriCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RelyingpartyCreateAuthUriCall<'a, C, A> {} -impl<'a, C, NC, A> RelyingpartyCreateAuthUriCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RelyingpartyCreateAuthUriCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1790,7 +1786,7 @@ impl<'a, C, NC, A> RelyingpartyCreateAuthUriCall<'a, C, NC, A> where NC: hyper:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &IdentitytoolkitRelyingpartyCreateAuthUriRequest) -> RelyingpartyCreateAuthUriCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &IdentitytoolkitRelyingpartyCreateAuthUriRequest) -> RelyingpartyCreateAuthUriCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1801,7 +1797,7 @@ impl<'a, C, NC, A> RelyingpartyCreateAuthUriCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RelyingpartyCreateAuthUriCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RelyingpartyCreateAuthUriCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1822,7 +1818,7 @@ impl<'a, C, NC, A> RelyingpartyCreateAuthUriCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RelyingpartyCreateAuthUriCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RelyingpartyCreateAuthUriCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1867,18 +1863,18 @@ impl<'a, C, NC, A> RelyingpartyCreateAuthUriCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct RelyingpartyVerifyAssertionCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RelyingpartyVerifyAssertionCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a IdentityToolkit, + hub: &'a IdentityToolkit, _request: IdentitytoolkitRelyingpartyVerifyAssertionRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for RelyingpartyVerifyAssertionCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RelyingpartyVerifyAssertionCall<'a, C, A> {} -impl<'a, C, NC, A> RelyingpartyVerifyAssertionCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RelyingpartyVerifyAssertionCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1990,7 +1986,7 @@ impl<'a, C, NC, A> RelyingpartyVerifyAssertionCall<'a, C, NC, A> where NC: hyper /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &IdentitytoolkitRelyingpartyVerifyAssertionRequest) -> RelyingpartyVerifyAssertionCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &IdentitytoolkitRelyingpartyVerifyAssertionRequest) -> RelyingpartyVerifyAssertionCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2001,7 +1997,7 @@ impl<'a, C, NC, A> RelyingpartyVerifyAssertionCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RelyingpartyVerifyAssertionCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RelyingpartyVerifyAssertionCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2022,7 +2018,7 @@ impl<'a, C, NC, A> RelyingpartyVerifyAssertionCall<'a, C, NC, A> where NC: hyper /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RelyingpartyVerifyAssertionCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RelyingpartyVerifyAssertionCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2067,18 +2063,18 @@ impl<'a, C, NC, A> RelyingpartyVerifyAssertionCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct RelyingpartyUploadAccountCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RelyingpartyUploadAccountCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a IdentityToolkit, + hub: &'a IdentityToolkit, _request: IdentitytoolkitRelyingpartyUploadAccountRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for RelyingpartyUploadAccountCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RelyingpartyUploadAccountCall<'a, C, A> {} -impl<'a, C, NC, A> RelyingpartyUploadAccountCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RelyingpartyUploadAccountCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2190,7 +2186,7 @@ impl<'a, C, NC, A> RelyingpartyUploadAccountCall<'a, C, NC, A> where NC: hyper:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &IdentitytoolkitRelyingpartyUploadAccountRequest) -> RelyingpartyUploadAccountCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &IdentitytoolkitRelyingpartyUploadAccountRequest) -> RelyingpartyUploadAccountCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2201,7 +2197,7 @@ impl<'a, C, NC, A> RelyingpartyUploadAccountCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RelyingpartyUploadAccountCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RelyingpartyUploadAccountCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2222,7 +2218,7 @@ impl<'a, C, NC, A> RelyingpartyUploadAccountCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RelyingpartyUploadAccountCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RelyingpartyUploadAccountCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2267,18 +2263,18 @@ impl<'a, C, NC, A> RelyingpartyUploadAccountCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct RelyingpartyGetAccountInfoCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RelyingpartyGetAccountInfoCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a IdentityToolkit, + hub: &'a IdentityToolkit, _request: IdentitytoolkitRelyingpartyGetAccountInfoRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for RelyingpartyGetAccountInfoCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RelyingpartyGetAccountInfoCall<'a, C, A> {} -impl<'a, C, NC, A> RelyingpartyGetAccountInfoCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RelyingpartyGetAccountInfoCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2390,7 +2386,7 @@ impl<'a, C, NC, A> RelyingpartyGetAccountInfoCall<'a, C, NC, A> where NC: hyper: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &IdentitytoolkitRelyingpartyGetAccountInfoRequest) -> RelyingpartyGetAccountInfoCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &IdentitytoolkitRelyingpartyGetAccountInfoRequest) -> RelyingpartyGetAccountInfoCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2401,7 +2397,7 @@ impl<'a, C, NC, A> RelyingpartyGetAccountInfoCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RelyingpartyGetAccountInfoCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RelyingpartyGetAccountInfoCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2422,7 +2418,7 @@ impl<'a, C, NC, A> RelyingpartyGetAccountInfoCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RelyingpartyGetAccountInfoCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RelyingpartyGetAccountInfoCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2467,18 +2463,18 @@ impl<'a, C, NC, A> RelyingpartyGetAccountInfoCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct RelyingpartyResetPasswordCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RelyingpartyResetPasswordCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a IdentityToolkit, + hub: &'a IdentityToolkit, _request: IdentitytoolkitRelyingpartyResetPasswordRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for RelyingpartyResetPasswordCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RelyingpartyResetPasswordCall<'a, C, A> {} -impl<'a, C, NC, A> RelyingpartyResetPasswordCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RelyingpartyResetPasswordCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2590,7 +2586,7 @@ impl<'a, C, NC, A> RelyingpartyResetPasswordCall<'a, C, NC, A> where NC: hyper:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &IdentitytoolkitRelyingpartyResetPasswordRequest) -> RelyingpartyResetPasswordCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &IdentitytoolkitRelyingpartyResetPasswordRequest) -> RelyingpartyResetPasswordCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2601,7 +2597,7 @@ impl<'a, C, NC, A> RelyingpartyResetPasswordCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RelyingpartyResetPasswordCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RelyingpartyResetPasswordCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2622,7 +2618,7 @@ impl<'a, C, NC, A> RelyingpartyResetPasswordCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RelyingpartyResetPasswordCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RelyingpartyResetPasswordCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2667,18 +2663,18 @@ impl<'a, C, NC, A> RelyingpartyResetPasswordCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct RelyingpartyDownloadAccountCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RelyingpartyDownloadAccountCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a IdentityToolkit, + hub: &'a IdentityToolkit, _request: IdentitytoolkitRelyingpartyDownloadAccountRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for RelyingpartyDownloadAccountCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RelyingpartyDownloadAccountCall<'a, C, A> {} -impl<'a, C, NC, A> RelyingpartyDownloadAccountCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RelyingpartyDownloadAccountCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2790,7 +2786,7 @@ impl<'a, C, NC, A> RelyingpartyDownloadAccountCall<'a, C, NC, A> where NC: hyper /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &IdentitytoolkitRelyingpartyDownloadAccountRequest) -> RelyingpartyDownloadAccountCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &IdentitytoolkitRelyingpartyDownloadAccountRequest) -> RelyingpartyDownloadAccountCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2801,7 +2797,7 @@ impl<'a, C, NC, A> RelyingpartyDownloadAccountCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RelyingpartyDownloadAccountCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RelyingpartyDownloadAccountCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2822,7 +2818,7 @@ impl<'a, C, NC, A> RelyingpartyDownloadAccountCall<'a, C, NC, A> where NC: hyper /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RelyingpartyDownloadAccountCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RelyingpartyDownloadAccountCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2867,18 +2863,18 @@ impl<'a, C, NC, A> RelyingpartyDownloadAccountCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct RelyingpartySetAccountInfoCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RelyingpartySetAccountInfoCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a IdentityToolkit, + hub: &'a IdentityToolkit, _request: IdentitytoolkitRelyingpartySetAccountInfoRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for RelyingpartySetAccountInfoCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RelyingpartySetAccountInfoCall<'a, C, A> {} -impl<'a, C, NC, A> RelyingpartySetAccountInfoCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RelyingpartySetAccountInfoCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2990,7 +2986,7 @@ impl<'a, C, NC, A> RelyingpartySetAccountInfoCall<'a, C, NC, A> where NC: hyper: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &IdentitytoolkitRelyingpartySetAccountInfoRequest) -> RelyingpartySetAccountInfoCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &IdentitytoolkitRelyingpartySetAccountInfoRequest) -> RelyingpartySetAccountInfoCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3001,7 +2997,7 @@ impl<'a, C, NC, A> RelyingpartySetAccountInfoCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RelyingpartySetAccountInfoCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RelyingpartySetAccountInfoCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3022,7 +3018,7 @@ impl<'a, C, NC, A> RelyingpartySetAccountInfoCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RelyingpartySetAccountInfoCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RelyingpartySetAccountInfoCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3067,18 +3063,18 @@ impl<'a, C, NC, A> RelyingpartySetAccountInfoCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct RelyingpartyDeleteAccountCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RelyingpartyDeleteAccountCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a IdentityToolkit, + hub: &'a IdentityToolkit, _request: IdentitytoolkitRelyingpartyDeleteAccountRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for RelyingpartyDeleteAccountCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RelyingpartyDeleteAccountCall<'a, C, A> {} -impl<'a, C, NC, A> RelyingpartyDeleteAccountCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RelyingpartyDeleteAccountCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3190,7 +3186,7 @@ impl<'a, C, NC, A> RelyingpartyDeleteAccountCall<'a, C, NC, A> where NC: hyper:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &IdentitytoolkitRelyingpartyDeleteAccountRequest) -> RelyingpartyDeleteAccountCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &IdentitytoolkitRelyingpartyDeleteAccountRequest) -> RelyingpartyDeleteAccountCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3201,7 +3197,7 @@ impl<'a, C, NC, A> RelyingpartyDeleteAccountCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RelyingpartyDeleteAccountCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RelyingpartyDeleteAccountCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3222,7 +3218,7 @@ impl<'a, C, NC, A> RelyingpartyDeleteAccountCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RelyingpartyDeleteAccountCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RelyingpartyDeleteAccountCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3267,18 +3263,18 @@ impl<'a, C, NC, A> RelyingpartyDeleteAccountCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct RelyingpartyVerifyPasswordCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RelyingpartyVerifyPasswordCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a IdentityToolkit, + hub: &'a IdentityToolkit, _request: IdentitytoolkitRelyingpartyVerifyPasswordRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for RelyingpartyVerifyPasswordCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RelyingpartyVerifyPasswordCall<'a, C, A> {} -impl<'a, C, NC, A> RelyingpartyVerifyPasswordCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RelyingpartyVerifyPasswordCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3390,7 +3386,7 @@ impl<'a, C, NC, A> RelyingpartyVerifyPasswordCall<'a, C, NC, A> where NC: hyper: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &IdentitytoolkitRelyingpartyVerifyPasswordRequest) -> RelyingpartyVerifyPasswordCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &IdentitytoolkitRelyingpartyVerifyPasswordRequest) -> RelyingpartyVerifyPasswordCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3401,7 +3397,7 @@ impl<'a, C, NC, A> RelyingpartyVerifyPasswordCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RelyingpartyVerifyPasswordCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RelyingpartyVerifyPasswordCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3422,7 +3418,7 @@ impl<'a, C, NC, A> RelyingpartyVerifyPasswordCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RelyingpartyVerifyPasswordCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RelyingpartyVerifyPasswordCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self diff --git a/gen/licensing1/Cargo.toml b/gen/licensing1/Cargo.toml index 1fd8c9da0a8..2da1b7cc60a 100644 --- a/gen/licensing1/Cargo.toml +++ b/gen/licensing1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-licensing1" -version = "0.1.4+20140122" +version = "0.1.5+20140122" authors = ["Sebastian Thiel "] description = "A complete library to interact with licensing (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/licensing1" homepage = "https://developers.google.com/google-apps/licensing/" -documentation = "http://byron.github.io/google-apis-rs/google-licensing1" +documentation = "http://byron.github.io/google-apis-rs/google_licensing1" license = "MIT" keywords = ["licensing", "google", "protocol", "web", "api"] diff --git a/gen/licensing1/README.md b/gen/licensing1/README.md index c456daff84b..17e17b1a617 100644 --- a/gen/licensing1/README.md +++ b/gen/licensing1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-licensing1` library allows access to all features of the *Google licensing* service. -This documentation was generated from *licensing* crate version *0.1.4+20140122*, where *20140122* is the exact revision of the *licensing:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *licensing* crate version *0.1.5+20140122*, where *20140122* is the exact revision of the *licensing:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *licensing* *v1* API can be found at the [official documentation site](https://developers.google.com/google-apps/licensing/). diff --git a/gen/licensing1/src/cmn.rs b/gen/licensing1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/licensing1/src/cmn.rs +++ b/gen/licensing1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/licensing1/src/lib.rs b/gen/licensing1/src/lib.rs index d1ab68c1e18..c5b87e6e26b 100644 --- a/gen/licensing1/src/lib.rs +++ b/gen/licensing1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *licensing* crate version *0.1.4+20140122*, where *20140122* is the exact revision of the *licensing:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *licensing* crate version *0.1.5+20140122*, where *20140122* is the exact revision of the *licensing:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *licensing* *v1* API can be found at the //! [official documentation site](https://developers.google.com/google-apps/licensing/). @@ -196,7 +196,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -289,34 +288,31 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Licensing { +pub struct Licensing { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Licensing {} +impl<'a, C, A> Hub for Licensing {} -impl<'a, C, NC, A> Licensing - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Licensing + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Licensing { + pub fn new(client: C, authenticator: A) -> Licensing { Licensing { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn license_assignments(&'a self) -> LicenseAssignmentMethods<'a, C, NC, A> { + pub fn license_assignments(&'a self) -> LicenseAssignmentMethods<'a, C, A> { LicenseAssignmentMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -448,15 +444,15 @@ impl ResponseResult for LicenseAssignmentList {} /// let rb = hub.license_assignments(); /// # } /// ``` -pub struct LicenseAssignmentMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LicenseAssignmentMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Licensing, + hub: &'a Licensing, } -impl<'a, C, NC, A> MethodsBuilder for LicenseAssignmentMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for LicenseAssignmentMethods<'a, C, A> {} -impl<'a, C, NC, A> LicenseAssignmentMethods<'a, C, NC, A> { +impl<'a, C, A> LicenseAssignmentMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -467,7 +463,7 @@ impl<'a, C, NC, A> LicenseAssignmentMethods<'a, C, NC, A> { /// * `productId` - Name for product /// * `skuId` - Name for sku /// * `userId` - email id or unique Id of the user - pub fn delete(&self, product_id: &str, sku_id: &str, user_id: &str) -> LicenseAssignmentDeleteCall<'a, C, NC, A> { + pub fn delete(&self, product_id: &str, sku_id: &str, user_id: &str) -> LicenseAssignmentDeleteCall<'a, C, A> { LicenseAssignmentDeleteCall { hub: self.hub, _product_id: product_id.to_string(), @@ -487,7 +483,7 @@ impl<'a, C, NC, A> LicenseAssignmentMethods<'a, C, NC, A> { /// /// * `productId` - Name for product /// * `customerId` - CustomerId represents the customer for whom licenseassignments are queried - pub fn list_for_product(&self, product_id: &str, customer_id: &str) -> LicenseAssignmentListForProductCall<'a, C, NC, A> { + pub fn list_for_product(&self, product_id: &str, customer_id: &str) -> LicenseAssignmentListForProductCall<'a, C, A> { LicenseAssignmentListForProductCall { hub: self.hub, _product_id: product_id.to_string(), @@ -509,7 +505,7 @@ impl<'a, C, NC, A> LicenseAssignmentMethods<'a, C, NC, A> { /// * `productId` - Name for product /// * `skuId` - Name for sku /// * `userId` - email id or unique Id of the user - pub fn get(&self, product_id: &str, sku_id: &str, user_id: &str) -> LicenseAssignmentGetCall<'a, C, NC, A> { + pub fn get(&self, product_id: &str, sku_id: &str, user_id: &str) -> LicenseAssignmentGetCall<'a, C, A> { LicenseAssignmentGetCall { hub: self.hub, _product_id: product_id.to_string(), @@ -530,7 +526,7 @@ impl<'a, C, NC, A> LicenseAssignmentMethods<'a, C, NC, A> { /// * `productId` - Name for product /// * `skuId` - Name for sku /// * `customerId` - CustomerId represents the customer for whom licenseassignments are queried - pub fn list_for_product_and_sku(&self, product_id: &str, sku_id: &str, customer_id: &str) -> LicenseAssignmentListForProductAndSkuCall<'a, C, NC, A> { + pub fn list_for_product_and_sku(&self, product_id: &str, sku_id: &str, customer_id: &str) -> LicenseAssignmentListForProductAndSkuCall<'a, C, A> { LicenseAssignmentListForProductAndSkuCall { hub: self.hub, _product_id: product_id.to_string(), @@ -554,7 +550,7 @@ impl<'a, C, NC, A> LicenseAssignmentMethods<'a, C, NC, A> { /// * `productId` - Name for product /// * `skuId` - Name for sku for which license would be revoked /// * `userId` - email id or unique Id of the user - pub fn update(&self, request: &LicenseAssignment, product_id: &str, sku_id: &str, user_id: &str) -> LicenseAssignmentUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &LicenseAssignment, product_id: &str, sku_id: &str, user_id: &str) -> LicenseAssignmentUpdateCall<'a, C, A> { LicenseAssignmentUpdateCall { hub: self.hub, _request: request.clone(), @@ -577,7 +573,7 @@ impl<'a, C, NC, A> LicenseAssignmentMethods<'a, C, NC, A> { /// * `productId` - Name for product /// * `skuId` - Name for sku for which license would be revoked /// * `userId` - email id or unique Id of the user - pub fn patch(&self, request: &LicenseAssignment, product_id: &str, sku_id: &str, user_id: &str) -> LicenseAssignmentPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &LicenseAssignment, product_id: &str, sku_id: &str, user_id: &str) -> LicenseAssignmentPatchCall<'a, C, A> { LicenseAssignmentPatchCall { hub: self.hub, _request: request.clone(), @@ -599,7 +595,7 @@ impl<'a, C, NC, A> LicenseAssignmentMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `productId` - Name for product /// * `skuId` - Name for sku - pub fn insert(&self, request: &LicenseAssignmentInsert, product_id: &str, sku_id: &str) -> LicenseAssignmentInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &LicenseAssignmentInsert, product_id: &str, sku_id: &str) -> LicenseAssignmentInsertCall<'a, C, A> { LicenseAssignmentInsertCall { hub: self.hub, _request: request.clone(), @@ -650,10 +646,10 @@ impl<'a, C, NC, A> LicenseAssignmentMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct LicenseAssignmentDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LicenseAssignmentDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Licensing, + hub: &'a Licensing, _product_id: String, _sku_id: String, _user_id: String, @@ -662,9 +658,9 @@ pub struct LicenseAssignmentDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LicenseAssignmentDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LicenseAssignmentDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> LicenseAssignmentDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LicenseAssignmentDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -787,7 +783,7 @@ impl<'a, C, NC, A> LicenseAssignmentDeleteCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Name for product - pub fn product_id(mut self, new_value: &str) -> LicenseAssignmentDeleteCall<'a, C, NC, A> { + pub fn product_id(mut self, new_value: &str) -> LicenseAssignmentDeleteCall<'a, C, A> { self._product_id = new_value.to_string(); self } @@ -797,7 +793,7 @@ impl<'a, C, NC, A> LicenseAssignmentDeleteCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Name for sku - pub fn sku_id(mut self, new_value: &str) -> LicenseAssignmentDeleteCall<'a, C, NC, A> { + pub fn sku_id(mut self, new_value: &str) -> LicenseAssignmentDeleteCall<'a, C, A> { self._sku_id = new_value.to_string(); self } @@ -807,7 +803,7 @@ impl<'a, C, NC, A> LicenseAssignmentDeleteCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// email id or unique Id of the user - pub fn user_id(mut self, new_value: &str) -> LicenseAssignmentDeleteCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> LicenseAssignmentDeleteCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -818,7 +814,7 @@ impl<'a, C, NC, A> LicenseAssignmentDeleteCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LicenseAssignmentDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LicenseAssignmentDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -839,7 +835,7 @@ impl<'a, C, NC, A> LicenseAssignmentDeleteCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LicenseAssignmentDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LicenseAssignmentDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -856,7 +852,7 @@ impl<'a, C, NC, A> LicenseAssignmentDeleteCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LicenseAssignmentDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LicenseAssignmentDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -896,10 +892,10 @@ impl<'a, C, NC, A> LicenseAssignmentDeleteCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct LicenseAssignmentListForProductCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LicenseAssignmentListForProductCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Licensing, + hub: &'a Licensing, _product_id: String, _customer_id: String, _page_token: Option, @@ -909,9 +905,9 @@ pub struct LicenseAssignmentListForProductCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LicenseAssignmentListForProductCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LicenseAssignmentListForProductCall<'a, C, A> {} -impl<'a, C, NC, A> LicenseAssignmentListForProductCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LicenseAssignmentListForProductCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1050,7 +1046,7 @@ impl<'a, C, NC, A> LicenseAssignmentListForProductCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Name for product - pub fn product_id(mut self, new_value: &str) -> LicenseAssignmentListForProductCall<'a, C, NC, A> { + pub fn product_id(mut self, new_value: &str) -> LicenseAssignmentListForProductCall<'a, C, A> { self._product_id = new_value.to_string(); self } @@ -1060,7 +1056,7 @@ impl<'a, C, NC, A> LicenseAssignmentListForProductCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// CustomerId represents the customer for whom licenseassignments are queried - pub fn customer_id(mut self, new_value: &str) -> LicenseAssignmentListForProductCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> LicenseAssignmentListForProductCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -1068,7 +1064,7 @@ impl<'a, C, NC, A> LicenseAssignmentListForProductCall<'a, C, NC, A> where NC: h /// /// /// Token to fetch the next page.Optional. By default server will return first page - pub fn page_token(mut self, new_value: &str) -> LicenseAssignmentListForProductCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> LicenseAssignmentListForProductCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -1076,7 +1072,7 @@ impl<'a, C, NC, A> LicenseAssignmentListForProductCall<'a, C, NC, A> where NC: h /// /// /// Maximum number of campaigns to return at one time. Must be positive. Optional. Default value is 100. - pub fn max_results(mut self, new_value: u32) -> LicenseAssignmentListForProductCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> LicenseAssignmentListForProductCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -1087,7 +1083,7 @@ impl<'a, C, NC, A> LicenseAssignmentListForProductCall<'a, C, NC, A> where NC: h /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LicenseAssignmentListForProductCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LicenseAssignmentListForProductCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1108,7 +1104,7 @@ impl<'a, C, NC, A> LicenseAssignmentListForProductCall<'a, C, NC, A> where NC: h /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LicenseAssignmentListForProductCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LicenseAssignmentListForProductCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1125,7 +1121,7 @@ impl<'a, C, NC, A> LicenseAssignmentListForProductCall<'a, C, NC, A> where NC: h /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LicenseAssignmentListForProductCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LicenseAssignmentListForProductCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1163,10 +1159,10 @@ impl<'a, C, NC, A> LicenseAssignmentListForProductCall<'a, C, NC, A> where NC: h /// .doit(); /// # } /// ``` -pub struct LicenseAssignmentGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LicenseAssignmentGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Licensing, + hub: &'a Licensing, _product_id: String, _sku_id: String, _user_id: String, @@ -1175,9 +1171,9 @@ pub struct LicenseAssignmentGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LicenseAssignmentGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LicenseAssignmentGetCall<'a, C, A> {} -impl<'a, C, NC, A> LicenseAssignmentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LicenseAssignmentGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1311,7 +1307,7 @@ impl<'a, C, NC, A> LicenseAssignmentGetCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Name for product - pub fn product_id(mut self, new_value: &str) -> LicenseAssignmentGetCall<'a, C, NC, A> { + pub fn product_id(mut self, new_value: &str) -> LicenseAssignmentGetCall<'a, C, A> { self._product_id = new_value.to_string(); self } @@ -1321,7 +1317,7 @@ impl<'a, C, NC, A> LicenseAssignmentGetCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Name for sku - pub fn sku_id(mut self, new_value: &str) -> LicenseAssignmentGetCall<'a, C, NC, A> { + pub fn sku_id(mut self, new_value: &str) -> LicenseAssignmentGetCall<'a, C, A> { self._sku_id = new_value.to_string(); self } @@ -1331,7 +1327,7 @@ impl<'a, C, NC, A> LicenseAssignmentGetCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// email id or unique Id of the user - pub fn user_id(mut self, new_value: &str) -> LicenseAssignmentGetCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> LicenseAssignmentGetCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -1342,7 +1338,7 @@ impl<'a, C, NC, A> LicenseAssignmentGetCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LicenseAssignmentGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LicenseAssignmentGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1363,7 +1359,7 @@ impl<'a, C, NC, A> LicenseAssignmentGetCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LicenseAssignmentGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LicenseAssignmentGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1380,7 +1376,7 @@ impl<'a, C, NC, A> LicenseAssignmentGetCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LicenseAssignmentGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LicenseAssignmentGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1420,10 +1416,10 @@ impl<'a, C, NC, A> LicenseAssignmentGetCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct LicenseAssignmentListForProductAndSkuCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LicenseAssignmentListForProductAndSkuCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Licensing, + hub: &'a Licensing, _product_id: String, _sku_id: String, _customer_id: String, @@ -1434,9 +1430,9 @@ pub struct LicenseAssignmentListForProductAndSkuCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LicenseAssignmentListForProductAndSkuCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LicenseAssignmentListForProductAndSkuCall<'a, C, A> {} -impl<'a, C, NC, A> LicenseAssignmentListForProductAndSkuCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LicenseAssignmentListForProductAndSkuCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1576,7 +1572,7 @@ impl<'a, C, NC, A> LicenseAssignmentListForProductAndSkuCall<'a, C, NC, A> where /// we provide this method for API completeness. /// /// Name for product - pub fn product_id(mut self, new_value: &str) -> LicenseAssignmentListForProductAndSkuCall<'a, C, NC, A> { + pub fn product_id(mut self, new_value: &str) -> LicenseAssignmentListForProductAndSkuCall<'a, C, A> { self._product_id = new_value.to_string(); self } @@ -1586,7 +1582,7 @@ impl<'a, C, NC, A> LicenseAssignmentListForProductAndSkuCall<'a, C, NC, A> where /// we provide this method for API completeness. /// /// Name for sku - pub fn sku_id(mut self, new_value: &str) -> LicenseAssignmentListForProductAndSkuCall<'a, C, NC, A> { + pub fn sku_id(mut self, new_value: &str) -> LicenseAssignmentListForProductAndSkuCall<'a, C, A> { self._sku_id = new_value.to_string(); self } @@ -1596,7 +1592,7 @@ impl<'a, C, NC, A> LicenseAssignmentListForProductAndSkuCall<'a, C, NC, A> where /// we provide this method for API completeness. /// /// CustomerId represents the customer for whom licenseassignments are queried - pub fn customer_id(mut self, new_value: &str) -> LicenseAssignmentListForProductAndSkuCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> LicenseAssignmentListForProductAndSkuCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -1604,7 +1600,7 @@ impl<'a, C, NC, A> LicenseAssignmentListForProductAndSkuCall<'a, C, NC, A> where /// /// /// Token to fetch the next page.Optional. By default server will return first page - pub fn page_token(mut self, new_value: &str) -> LicenseAssignmentListForProductAndSkuCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> LicenseAssignmentListForProductAndSkuCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -1612,7 +1608,7 @@ impl<'a, C, NC, A> LicenseAssignmentListForProductAndSkuCall<'a, C, NC, A> where /// /// /// Maximum number of campaigns to return at one time. Must be positive. Optional. Default value is 100. - pub fn max_results(mut self, new_value: u32) -> LicenseAssignmentListForProductAndSkuCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> LicenseAssignmentListForProductAndSkuCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -1623,7 +1619,7 @@ impl<'a, C, NC, A> LicenseAssignmentListForProductAndSkuCall<'a, C, NC, A> where /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LicenseAssignmentListForProductAndSkuCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LicenseAssignmentListForProductAndSkuCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1644,7 +1640,7 @@ impl<'a, C, NC, A> LicenseAssignmentListForProductAndSkuCall<'a, C, NC, A> where /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LicenseAssignmentListForProductAndSkuCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LicenseAssignmentListForProductAndSkuCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1661,7 +1657,7 @@ impl<'a, C, NC, A> LicenseAssignmentListForProductAndSkuCall<'a, C, NC, A> where /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LicenseAssignmentListForProductAndSkuCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LicenseAssignmentListForProductAndSkuCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1705,10 +1701,10 @@ impl<'a, C, NC, A> LicenseAssignmentListForProductAndSkuCall<'a, C, NC, A> where /// .doit(); /// # } /// ``` -pub struct LicenseAssignmentUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LicenseAssignmentUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Licensing, + hub: &'a Licensing, _request: LicenseAssignment, _product_id: String, _sku_id: String, @@ -1718,9 +1714,9 @@ pub struct LicenseAssignmentUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LicenseAssignmentUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LicenseAssignmentUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> LicenseAssignmentUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LicenseAssignmentUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1861,7 +1857,7 @@ impl<'a, C, NC, A> LicenseAssignmentUpdateCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &LicenseAssignment) -> LicenseAssignmentUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &LicenseAssignment) -> LicenseAssignmentUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1871,7 +1867,7 @@ impl<'a, C, NC, A> LicenseAssignmentUpdateCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Name for product - pub fn product_id(mut self, new_value: &str) -> LicenseAssignmentUpdateCall<'a, C, NC, A> { + pub fn product_id(mut self, new_value: &str) -> LicenseAssignmentUpdateCall<'a, C, A> { self._product_id = new_value.to_string(); self } @@ -1881,7 +1877,7 @@ impl<'a, C, NC, A> LicenseAssignmentUpdateCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Name for sku for which license would be revoked - pub fn sku_id(mut self, new_value: &str) -> LicenseAssignmentUpdateCall<'a, C, NC, A> { + pub fn sku_id(mut self, new_value: &str) -> LicenseAssignmentUpdateCall<'a, C, A> { self._sku_id = new_value.to_string(); self } @@ -1891,7 +1887,7 @@ impl<'a, C, NC, A> LicenseAssignmentUpdateCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// email id or unique Id of the user - pub fn user_id(mut self, new_value: &str) -> LicenseAssignmentUpdateCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> LicenseAssignmentUpdateCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -1902,7 +1898,7 @@ impl<'a, C, NC, A> LicenseAssignmentUpdateCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LicenseAssignmentUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LicenseAssignmentUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1923,7 +1919,7 @@ impl<'a, C, NC, A> LicenseAssignmentUpdateCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LicenseAssignmentUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LicenseAssignmentUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1940,7 +1936,7 @@ impl<'a, C, NC, A> LicenseAssignmentUpdateCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LicenseAssignmentUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LicenseAssignmentUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1984,10 +1980,10 @@ impl<'a, C, NC, A> LicenseAssignmentUpdateCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct LicenseAssignmentPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LicenseAssignmentPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Licensing, + hub: &'a Licensing, _request: LicenseAssignment, _product_id: String, _sku_id: String, @@ -1997,9 +1993,9 @@ pub struct LicenseAssignmentPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LicenseAssignmentPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LicenseAssignmentPatchCall<'a, C, A> {} -impl<'a, C, NC, A> LicenseAssignmentPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LicenseAssignmentPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2140,7 +2136,7 @@ impl<'a, C, NC, A> LicenseAssignmentPatchCall<'a, C, NC, A> where NC: hyper::net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &LicenseAssignment) -> LicenseAssignmentPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &LicenseAssignment) -> LicenseAssignmentPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2150,7 +2146,7 @@ impl<'a, C, NC, A> LicenseAssignmentPatchCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Name for product - pub fn product_id(mut self, new_value: &str) -> LicenseAssignmentPatchCall<'a, C, NC, A> { + pub fn product_id(mut self, new_value: &str) -> LicenseAssignmentPatchCall<'a, C, A> { self._product_id = new_value.to_string(); self } @@ -2160,7 +2156,7 @@ impl<'a, C, NC, A> LicenseAssignmentPatchCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Name for sku for which license would be revoked - pub fn sku_id(mut self, new_value: &str) -> LicenseAssignmentPatchCall<'a, C, NC, A> { + pub fn sku_id(mut self, new_value: &str) -> LicenseAssignmentPatchCall<'a, C, A> { self._sku_id = new_value.to_string(); self } @@ -2170,7 +2166,7 @@ impl<'a, C, NC, A> LicenseAssignmentPatchCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// email id or unique Id of the user - pub fn user_id(mut self, new_value: &str) -> LicenseAssignmentPatchCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> LicenseAssignmentPatchCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -2181,7 +2177,7 @@ impl<'a, C, NC, A> LicenseAssignmentPatchCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LicenseAssignmentPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LicenseAssignmentPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2202,7 +2198,7 @@ impl<'a, C, NC, A> LicenseAssignmentPatchCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LicenseAssignmentPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LicenseAssignmentPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2219,7 +2215,7 @@ impl<'a, C, NC, A> LicenseAssignmentPatchCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LicenseAssignmentPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LicenseAssignmentPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2263,10 +2259,10 @@ impl<'a, C, NC, A> LicenseAssignmentPatchCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct LicenseAssignmentInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LicenseAssignmentInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Licensing, + hub: &'a Licensing, _request: LicenseAssignmentInsert, _product_id: String, _sku_id: String, @@ -2275,9 +2271,9 @@ pub struct LicenseAssignmentInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LicenseAssignmentInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LicenseAssignmentInsertCall<'a, C, A> {} -impl<'a, C, NC, A> LicenseAssignmentInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LicenseAssignmentInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2417,7 +2413,7 @@ impl<'a, C, NC, A> LicenseAssignmentInsertCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &LicenseAssignmentInsert) -> LicenseAssignmentInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &LicenseAssignmentInsert) -> LicenseAssignmentInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2427,7 +2423,7 @@ impl<'a, C, NC, A> LicenseAssignmentInsertCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Name for product - pub fn product_id(mut self, new_value: &str) -> LicenseAssignmentInsertCall<'a, C, NC, A> { + pub fn product_id(mut self, new_value: &str) -> LicenseAssignmentInsertCall<'a, C, A> { self._product_id = new_value.to_string(); self } @@ -2437,7 +2433,7 @@ impl<'a, C, NC, A> LicenseAssignmentInsertCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Name for sku - pub fn sku_id(mut self, new_value: &str) -> LicenseAssignmentInsertCall<'a, C, NC, A> { + pub fn sku_id(mut self, new_value: &str) -> LicenseAssignmentInsertCall<'a, C, A> { self._sku_id = new_value.to_string(); self } @@ -2448,7 +2444,7 @@ impl<'a, C, NC, A> LicenseAssignmentInsertCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LicenseAssignmentInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LicenseAssignmentInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2469,7 +2465,7 @@ impl<'a, C, NC, A> LicenseAssignmentInsertCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LicenseAssignmentInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LicenseAssignmentInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2486,7 +2482,7 @@ impl<'a, C, NC, A> LicenseAssignmentInsertCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LicenseAssignmentInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LicenseAssignmentInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/logging1_beta3/Cargo.toml b/gen/logging1_beta3/Cargo.toml index d828663f557..c4d7ff7af33 100644 --- a/gen/logging1_beta3/Cargo.toml +++ b/gen/logging1_beta3/Cargo.toml @@ -4,11 +4,11 @@ [package] name = "google-logging1_beta3" -version = "0.1.4+20150326" +version = "0.1.5+20150326" authors = ["Sebastian Thiel "] description = "A complete library to interact with logging (protocol v1beta3)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/logging1_beta3" -documentation = "http://byron.github.io/google-apis-rs/google-logging1_beta3" +documentation = "http://byron.github.io/google-apis-rs/google_logging1_beta3" license = "MIT" keywords = ["logging", "google", "protocol", "web", "api"] diff --git a/gen/logging1_beta3/README.md b/gen/logging1_beta3/README.md index 566ac4847f7..5bd7d146f85 100644 --- a/gen/logging1_beta3/README.md +++ b/gen/logging1_beta3/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-logging1_beta3` library allows access to all features of the *Google logging* service. -This documentation was generated from *logging* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *logging:v1beta3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *logging* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *logging:v1beta3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. # Features Handle the following *Resources* with ease from the central [hub](http://byron.github.io/google-apis-rs/google-logging1_beta3/struct.Logging.html) ... diff --git a/gen/logging1_beta3/src/cmn.rs b/gen/logging1_beta3/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/logging1_beta3/src/cmn.rs +++ b/gen/logging1_beta3/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/logging1_beta3/src/lib.rs b/gen/logging1_beta3/src/lib.rs index 1758f195f52..d4364506ab7 100644 --- a/gen/logging1_beta3/src/lib.rs +++ b/gen/logging1_beta3/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *logging* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *logging:v1beta3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *logging* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *logging:v1beta3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/master/gen/logging1_beta3). //! # Features //! @@ -196,7 +196,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -293,34 +292,31 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Logging { +pub struct Logging { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Logging {} +impl<'a, C, A> Hub for Logging {} -impl<'a, C, NC, A> Logging - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Logging + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Logging { + pub fn new(client: C, authenticator: A) -> Logging { Logging { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn projects(&'a self) -> ProjectMethods<'a, C, NC, A> { + pub fn projects(&'a self) -> ProjectMethods<'a, C, A> { ProjectMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -676,15 +672,15 @@ impl ResponseResult for ListLogServiceSinksResponse {} /// let rb = hub.projects(); /// # } /// ``` -pub struct ProjectMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Logging, + hub: &'a Logging, } -impl<'a, C, NC, A> MethodsBuilder for ProjectMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ProjectMethods<'a, C, A> {} -impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { +impl<'a, C, A> ProjectMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -693,7 +689,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// # Arguments /// /// * `projectsId` - Part of `projectName`. The project resource whose services are to be listed. - pub fn log_services_list(&self, projects_id: &str) -> ProjectLogServiceListCall<'a, C, NC, A> { + pub fn log_services_list(&self, projects_id: &str) -> ProjectLogServiceListCall<'a, C, A> { ProjectLogServiceListCall { hub: self.hub, _projects_id: projects_id.to_string(), @@ -713,7 +709,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// # Arguments /// /// * `projectsId` - Part of `projectName`. The project name for which to list the log resources. - pub fn logs_list(&self, projects_id: &str) -> ProjectLogListCall<'a, C, NC, A> { + pub fn logs_list(&self, projects_id: &str) -> ProjectLogListCall<'a, C, A> { ProjectLogListCall { hub: self.hub, _projects_id: projects_id.to_string(), @@ -736,7 +732,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// * `projectsId` - Part of `sinkName`. The name of the sink resource to return. /// * `logsId` - Part of `sinkName`. See documentation of `projectsId`. /// * `sinksId` - Part of `sinkName`. See documentation of `projectsId`. - pub fn logs_sinks_get(&self, projects_id: &str, logs_id: &str, sinks_id: &str) -> ProjectLogSinkGetCall<'a, C, NC, A> { + pub fn logs_sinks_get(&self, projects_id: &str, logs_id: &str, sinks_id: &str) -> ProjectLogSinkGetCall<'a, C, A> { ProjectLogSinkGetCall { hub: self.hub, _projects_id: projects_id.to_string(), @@ -758,7 +754,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// * `projectsId` - Part of `sinkName`. The name of the sink to update. /// * `logServicesId` - Part of `sinkName`. See documentation of `projectsId`. /// * `sinksId` - Part of `sinkName`. See documentation of `projectsId`. - pub fn log_services_sinks_update(&self, request: &LogSink, projects_id: &str, log_services_id: &str, sinks_id: &str) -> ProjectLogServiceSinkUpdateCall<'a, C, NC, A> { + pub fn log_services_sinks_update(&self, request: &LogSink, projects_id: &str, log_services_id: &str, sinks_id: &str) -> ProjectLogServiceSinkUpdateCall<'a, C, A> { ProjectLogServiceSinkUpdateCall { hub: self.hub, _request: request.clone(), @@ -780,7 +776,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `projectsId` - Part of `logName`. The name of the log resource into which to insert the log entries. /// * `logsId` - Part of `logName`. See documentation of `projectsId`. - pub fn logs_entries_write(&self, request: &WriteLogEntriesRequest, projects_id: &str, logs_id: &str) -> ProjectLogEntryWriteCall<'a, C, NC, A> { + pub fn logs_entries_write(&self, request: &WriteLogEntriesRequest, projects_id: &str, logs_id: &str) -> ProjectLogEntryWriteCall<'a, C, A> { ProjectLogEntryWriteCall { hub: self.hub, _request: request.clone(), @@ -801,7 +797,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// * `projectsId` - Part of `sinkName`. The name of the sink to delete. /// * `logServicesId` - Part of `sinkName`. See documentation of `projectsId`. /// * `sinksId` - Part of `sinkName`. See documentation of `projectsId`. - pub fn log_services_sinks_delete(&self, projects_id: &str, log_services_id: &str, sinks_id: &str) -> ProjectLogServiceSinkDeleteCall<'a, C, NC, A> { + pub fn log_services_sinks_delete(&self, projects_id: &str, log_services_id: &str, sinks_id: &str) -> ProjectLogServiceSinkDeleteCall<'a, C, A> { ProjectLogServiceSinkDeleteCall { hub: self.hub, _projects_id: projects_id.to_string(), @@ -821,7 +817,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// /// * `projectsId` - Part of `serviceName`. A log service resource of the form `/projects/*/logServices/*`. The service indexes of the log service are returned. Example: `"/projects/myProj/logServices/appengine.googleapis.com"`. /// * `logServicesId` - Part of `serviceName`. See documentation of `projectsId`. - pub fn log_services_indexes_list(&self, projects_id: &str, log_services_id: &str) -> ProjectLogServiceIndexeListCall<'a, C, NC, A> { + pub fn log_services_indexes_list(&self, projects_id: &str, log_services_id: &str) -> ProjectLogServiceIndexeListCall<'a, C, A> { ProjectLogServiceIndexeListCall { hub: self.hub, _projects_id: projects_id.to_string(), @@ -845,7 +841,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// /// * `projectsId` - Part of `logName`. The log for which to list sinks. /// * `logsId` - Part of `logName`. See documentation of `projectsId`. - pub fn logs_sinks_list(&self, projects_id: &str, logs_id: &str) -> ProjectLogSinkListCall<'a, C, NC, A> { + pub fn logs_sinks_list(&self, projects_id: &str, logs_id: &str) -> ProjectLogSinkListCall<'a, C, A> { ProjectLogSinkListCall { hub: self.hub, _projects_id: projects_id.to_string(), @@ -866,7 +862,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// * `projectsId` - Part of `sinkName`. The name of the sink to update. /// * `logsId` - Part of `sinkName`. See documentation of `projectsId`. /// * `sinksId` - Part of `sinkName`. See documentation of `projectsId`. - pub fn logs_sinks_update(&self, request: &LogSink, projects_id: &str, logs_id: &str, sinks_id: &str) -> ProjectLogSinkUpdateCall<'a, C, NC, A> { + pub fn logs_sinks_update(&self, request: &LogSink, projects_id: &str, logs_id: &str, sinks_id: &str) -> ProjectLogSinkUpdateCall<'a, C, A> { ProjectLogSinkUpdateCall { hub: self.hub, _request: request.clone(), @@ -888,7 +884,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `projectsId` - Part of `serviceName`. The name of the service in which to create a sink. /// * `logServicesId` - Part of `serviceName`. See documentation of `projectsId`. - pub fn log_services_sinks_create(&self, request: &LogSink, projects_id: &str, log_services_id: &str) -> ProjectLogServiceSinkCreateCall<'a, C, NC, A> { + pub fn log_services_sinks_create(&self, request: &LogSink, projects_id: &str, log_services_id: &str) -> ProjectLogServiceSinkCreateCall<'a, C, A> { ProjectLogServiceSinkCreateCall { hub: self.hub, _request: request.clone(), @@ -909,7 +905,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// * `projectsId` - Part of `sinkName`. The name of the sink to delete. /// * `logsId` - Part of `sinkName`. See documentation of `projectsId`. /// * `sinksId` - Part of `sinkName`. See documentation of `projectsId`. - pub fn logs_sinks_delete(&self, projects_id: &str, logs_id: &str, sinks_id: &str) -> ProjectLogSinkDeleteCall<'a, C, NC, A> { + pub fn logs_sinks_delete(&self, projects_id: &str, logs_id: &str, sinks_id: &str) -> ProjectLogSinkDeleteCall<'a, C, A> { ProjectLogSinkDeleteCall { hub: self.hub, _projects_id: projects_id.to_string(), @@ -930,7 +926,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `projectsId` - Part of `logName`. The log in which to create a sink resource. /// * `logsId` - Part of `logName`. See documentation of `projectsId`. - pub fn logs_sinks_create(&self, request: &LogSink, projects_id: &str, logs_id: &str) -> ProjectLogSinkCreateCall<'a, C, NC, A> { + pub fn logs_sinks_create(&self, request: &LogSink, projects_id: &str, logs_id: &str) -> ProjectLogSinkCreateCall<'a, C, A> { ProjectLogSinkCreateCall { hub: self.hub, _request: request.clone(), @@ -951,7 +947,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// * `projectsId` - Part of `sinkName`. The name of the sink to return. /// * `logServicesId` - Part of `sinkName`. See documentation of `projectsId`. /// * `sinksId` - Part of `sinkName`. See documentation of `projectsId`. - pub fn log_services_sinks_get(&self, projects_id: &str, log_services_id: &str, sinks_id: &str) -> ProjectLogServiceSinkGetCall<'a, C, NC, A> { + pub fn log_services_sinks_get(&self, projects_id: &str, log_services_id: &str, sinks_id: &str) -> ProjectLogServiceSinkGetCall<'a, C, A> { ProjectLogServiceSinkGetCall { hub: self.hub, _projects_id: projects_id.to_string(), @@ -971,7 +967,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// /// * `projectsId` - Part of `serviceName`. The name of the service for which to list sinks. /// * `logServicesId` - Part of `serviceName`. See documentation of `projectsId`. - pub fn log_services_sinks_list(&self, projects_id: &str, log_services_id: &str) -> ProjectLogServiceSinkListCall<'a, C, NC, A> { + pub fn log_services_sinks_list(&self, projects_id: &str, log_services_id: &str) -> ProjectLogServiceSinkListCall<'a, C, A> { ProjectLogServiceSinkListCall { hub: self.hub, _projects_id: projects_id.to_string(), @@ -990,7 +986,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// /// * `projectsId` - Part of `logName`. The log resource to delete. /// * `logsId` - Part of `logName`. See documentation of `projectsId`. - pub fn logs_delete(&self, projects_id: &str, logs_id: &str) -> ProjectLogDeleteCall<'a, C, NC, A> { + pub fn logs_delete(&self, projects_id: &str, logs_id: &str) -> ProjectLogDeleteCall<'a, C, A> { ProjectLogDeleteCall { hub: self.hub, _projects_id: projects_id.to_string(), @@ -1043,10 +1039,10 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct ProjectLogServiceListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectLogServiceListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Logging, + hub: &'a Logging, _projects_id: String, _page_token: Option, _page_size: Option, @@ -1056,9 +1052,9 @@ pub struct ProjectLogServiceListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectLogServiceListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectLogServiceListCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectLogServiceListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectLogServiceListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1199,7 +1195,7 @@ impl<'a, C, NC, A> ProjectLogServiceListCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Part of `projectName`. The project resource whose services are to be listed. - pub fn projects_id(mut self, new_value: &str) -> ProjectLogServiceListCall<'a, C, NC, A> { + pub fn projects_id(mut self, new_value: &str) -> ProjectLogServiceListCall<'a, C, A> { self._projects_id = new_value.to_string(); self } @@ -1207,7 +1203,7 @@ impl<'a, C, NC, A> ProjectLogServiceListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// An opaque token, returned as `nextPageToken` by a prior `ListLogServices` operation. If `pageToken` is supplied, then the other fields of this request are ignored, and instead the previous `ListLogServices` operation is continued. - pub fn page_token(mut self, new_value: &str) -> ProjectLogServiceListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ProjectLogServiceListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -1215,7 +1211,7 @@ impl<'a, C, NC, A> ProjectLogServiceListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// The maximum number of `LogService` objects to return in one operation. - pub fn page_size(mut self, new_value: i32) -> ProjectLogServiceListCall<'a, C, NC, A> { + pub fn page_size(mut self, new_value: i32) -> ProjectLogServiceListCall<'a, C, A> { self._page_size = Some(new_value); self } @@ -1223,7 +1219,7 @@ impl<'a, C, NC, A> ProjectLogServiceListCall<'a, C, NC, A> where NC: hyper::net: /// /// /// The name of the log resource whose services are to be listed. log for which to list services. When empty, all services are listed. - pub fn log(mut self, new_value: &str) -> ProjectLogServiceListCall<'a, C, NC, A> { + pub fn log(mut self, new_value: &str) -> ProjectLogServiceListCall<'a, C, A> { self._log = Some(new_value.to_string()); self } @@ -1234,7 +1230,7 @@ impl<'a, C, NC, A> ProjectLogServiceListCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogServiceListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogServiceListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1259,7 +1255,7 @@ impl<'a, C, NC, A> ProjectLogServiceListCall<'a, C, NC, A> where NC: hyper::net: /// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. /// * *alt* (query-string) - Data format for response. /// * *$.xgafv* (query-string) - V1 error format. - pub fn param(mut self, name: T, value: T) -> ProjectLogServiceListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectLogServiceListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1276,7 +1272,7 @@ impl<'a, C, NC, A> ProjectLogServiceListCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectLogServiceListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectLogServiceListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1318,10 +1314,10 @@ impl<'a, C, NC, A> ProjectLogServiceListCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct ProjectLogListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectLogListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Logging, + hub: &'a Logging, _projects_id: String, _service_name: Option, _service_index_prefix: Option, @@ -1332,9 +1328,9 @@ pub struct ProjectLogListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectLogListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectLogListCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectLogListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectLogListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1478,7 +1474,7 @@ impl<'a, C, NC, A> ProjectLogListCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Part of `projectName`. The project name for which to list the log resources. - pub fn projects_id(mut self, new_value: &str) -> ProjectLogListCall<'a, C, NC, A> { + pub fn projects_id(mut self, new_value: &str) -> ProjectLogListCall<'a, C, A> { self._projects_id = new_value.to_string(); self } @@ -1486,7 +1482,7 @@ impl<'a, C, NC, A> ProjectLogListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// A service name for which to list logs. Only logs containing entries whose metadata includes this service name are returned. If `serviceName` and `serviceIndexPrefix` are both empty, then all log names are returned. To list all log names, regardless of service, leave both the `serviceName` and `serviceIndexPrefix` empty. To list log names containing entries with a particular service name (or explicitly empty service name) set `serviceName` to the desired value and `serviceIndexPrefix` to `"/"`. - pub fn service_name(mut self, new_value: &str) -> ProjectLogListCall<'a, C, NC, A> { + pub fn service_name(mut self, new_value: &str) -> ProjectLogListCall<'a, C, A> { self._service_name = Some(new_value.to_string()); self } @@ -1494,7 +1490,7 @@ impl<'a, C, NC, A> ProjectLogListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// A log service index prefix for which to list logs. Only logs containing entries whose metadata that includes these label values (associated with index keys) are returned. The prefix is a slash separated list of values, and need not specify all index labels. An empty index (or a single slash) matches all log service indexes. - pub fn service_index_prefix(mut self, new_value: &str) -> ProjectLogListCall<'a, C, NC, A> { + pub fn service_index_prefix(mut self, new_value: &str) -> ProjectLogListCall<'a, C, A> { self._service_index_prefix = Some(new_value.to_string()); self } @@ -1502,7 +1498,7 @@ impl<'a, C, NC, A> ProjectLogListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// An opaque token, returned as `nextPageToken` by a prior `ListLogs` operation. If `pageToken` is supplied, then the other fields of this request are ignored, and instead the previous `ListLogs` operation is continued. - pub fn page_token(mut self, new_value: &str) -> ProjectLogListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ProjectLogListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -1510,7 +1506,7 @@ impl<'a, C, NC, A> ProjectLogListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The maximum number of results to return. - pub fn page_size(mut self, new_value: i32) -> ProjectLogListCall<'a, C, NC, A> { + pub fn page_size(mut self, new_value: i32) -> ProjectLogListCall<'a, C, A> { self._page_size = Some(new_value); self } @@ -1521,7 +1517,7 @@ impl<'a, C, NC, A> ProjectLogListCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1546,7 +1542,7 @@ impl<'a, C, NC, A> ProjectLogListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. /// * *alt* (query-string) - Data format for response. /// * *$.xgafv* (query-string) - V1 error format. - pub fn param(mut self, name: T, value: T) -> ProjectLogListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectLogListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1563,7 +1559,7 @@ impl<'a, C, NC, A> ProjectLogListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectLogListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectLogListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1601,10 +1597,10 @@ impl<'a, C, NC, A> ProjectLogListCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct ProjectLogSinkGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectLogSinkGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Logging, + hub: &'a Logging, _projects_id: String, _logs_id: String, _sinks_id: String, @@ -1613,9 +1609,9 @@ pub struct ProjectLogSinkGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectLogSinkGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectLogSinkGetCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectLogSinkGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectLogSinkGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1749,7 +1745,7 @@ impl<'a, C, NC, A> ProjectLogSinkGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Part of `sinkName`. The name of the sink resource to return. - pub fn projects_id(mut self, new_value: &str) -> ProjectLogSinkGetCall<'a, C, NC, A> { + pub fn projects_id(mut self, new_value: &str) -> ProjectLogSinkGetCall<'a, C, A> { self._projects_id = new_value.to_string(); self } @@ -1759,7 +1755,7 @@ impl<'a, C, NC, A> ProjectLogSinkGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Part of `sinkName`. See documentation of `projectsId`. - pub fn logs_id(mut self, new_value: &str) -> ProjectLogSinkGetCall<'a, C, NC, A> { + pub fn logs_id(mut self, new_value: &str) -> ProjectLogSinkGetCall<'a, C, A> { self._logs_id = new_value.to_string(); self } @@ -1769,7 +1765,7 @@ impl<'a, C, NC, A> ProjectLogSinkGetCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Part of `sinkName`. See documentation of `projectsId`. - pub fn sinks_id(mut self, new_value: &str) -> ProjectLogSinkGetCall<'a, C, NC, A> { + pub fn sinks_id(mut self, new_value: &str) -> ProjectLogSinkGetCall<'a, C, A> { self._sinks_id = new_value.to_string(); self } @@ -1780,7 +1776,7 @@ impl<'a, C, NC, A> ProjectLogSinkGetCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogSinkGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogSinkGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1805,7 +1801,7 @@ impl<'a, C, NC, A> ProjectLogSinkGetCall<'a, C, NC, A> where NC: hyper::net::Net /// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. /// * *alt* (query-string) - Data format for response. /// * *$.xgafv* (query-string) - V1 error format. - pub fn param(mut self, name: T, value: T) -> ProjectLogSinkGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectLogSinkGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1822,7 +1818,7 @@ impl<'a, C, NC, A> ProjectLogSinkGetCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectLogSinkGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectLogSinkGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1866,10 +1862,10 @@ impl<'a, C, NC, A> ProjectLogSinkGetCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct ProjectLogServiceSinkUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectLogServiceSinkUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Logging, + hub: &'a Logging, _request: LogSink, _projects_id: String, _log_services_id: String, @@ -1879,9 +1875,9 @@ pub struct ProjectLogServiceSinkUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectLogServiceSinkUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectLogServiceSinkUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectLogServiceSinkUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectLogServiceSinkUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2022,7 +2018,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkUpdateCall<'a, C, NC, A> where NC: hyper /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &LogSink) -> ProjectLogServiceSinkUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &LogSink) -> ProjectLogServiceSinkUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2032,7 +2028,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkUpdateCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// Part of `sinkName`. The name of the sink to update. - pub fn projects_id(mut self, new_value: &str) -> ProjectLogServiceSinkUpdateCall<'a, C, NC, A> { + pub fn projects_id(mut self, new_value: &str) -> ProjectLogServiceSinkUpdateCall<'a, C, A> { self._projects_id = new_value.to_string(); self } @@ -2042,7 +2038,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkUpdateCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// Part of `sinkName`. See documentation of `projectsId`. - pub fn log_services_id(mut self, new_value: &str) -> ProjectLogServiceSinkUpdateCall<'a, C, NC, A> { + pub fn log_services_id(mut self, new_value: &str) -> ProjectLogServiceSinkUpdateCall<'a, C, A> { self._log_services_id = new_value.to_string(); self } @@ -2052,7 +2048,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkUpdateCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// Part of `sinkName`. See documentation of `projectsId`. - pub fn sinks_id(mut self, new_value: &str) -> ProjectLogServiceSinkUpdateCall<'a, C, NC, A> { + pub fn sinks_id(mut self, new_value: &str) -> ProjectLogServiceSinkUpdateCall<'a, C, A> { self._sinks_id = new_value.to_string(); self } @@ -2063,7 +2059,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkUpdateCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogServiceSinkUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogServiceSinkUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2088,7 +2084,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkUpdateCall<'a, C, NC, A> where NC: hyper /// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. /// * *alt* (query-string) - Data format for response. /// * *$.xgafv* (query-string) - V1 error format. - pub fn param(mut self, name: T, value: T) -> ProjectLogServiceSinkUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectLogServiceSinkUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2105,7 +2101,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkUpdateCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectLogServiceSinkUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectLogServiceSinkUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2149,10 +2145,10 @@ impl<'a, C, NC, A> ProjectLogServiceSinkUpdateCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct ProjectLogEntryWriteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectLogEntryWriteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Logging, + hub: &'a Logging, _request: WriteLogEntriesRequest, _projects_id: String, _logs_id: String, @@ -2161,9 +2157,9 @@ pub struct ProjectLogEntryWriteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectLogEntryWriteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectLogEntryWriteCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectLogEntryWriteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectLogEntryWriteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2303,7 +2299,7 @@ impl<'a, C, NC, A> ProjectLogEntryWriteCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &WriteLogEntriesRequest) -> ProjectLogEntryWriteCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &WriteLogEntriesRequest) -> ProjectLogEntryWriteCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2313,7 +2309,7 @@ impl<'a, C, NC, A> ProjectLogEntryWriteCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Part of `logName`. The name of the log resource into which to insert the log entries. - pub fn projects_id(mut self, new_value: &str) -> ProjectLogEntryWriteCall<'a, C, NC, A> { + pub fn projects_id(mut self, new_value: &str) -> ProjectLogEntryWriteCall<'a, C, A> { self._projects_id = new_value.to_string(); self } @@ -2323,7 +2319,7 @@ impl<'a, C, NC, A> ProjectLogEntryWriteCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Part of `logName`. See documentation of `projectsId`. - pub fn logs_id(mut self, new_value: &str) -> ProjectLogEntryWriteCall<'a, C, NC, A> { + pub fn logs_id(mut self, new_value: &str) -> ProjectLogEntryWriteCall<'a, C, A> { self._logs_id = new_value.to_string(); self } @@ -2334,7 +2330,7 @@ impl<'a, C, NC, A> ProjectLogEntryWriteCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogEntryWriteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogEntryWriteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2359,7 +2355,7 @@ impl<'a, C, NC, A> ProjectLogEntryWriteCall<'a, C, NC, A> where NC: hyper::net:: /// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. /// * *alt* (query-string) - Data format for response. /// * *$.xgafv* (query-string) - V1 error format. - pub fn param(mut self, name: T, value: T) -> ProjectLogEntryWriteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectLogEntryWriteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2376,7 +2372,7 @@ impl<'a, C, NC, A> ProjectLogEntryWriteCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectLogEntryWriteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectLogEntryWriteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2414,10 +2410,10 @@ impl<'a, C, NC, A> ProjectLogEntryWriteCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct ProjectLogServiceSinkDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectLogServiceSinkDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Logging, + hub: &'a Logging, _projects_id: String, _log_services_id: String, _sinks_id: String, @@ -2426,9 +2422,9 @@ pub struct ProjectLogServiceSinkDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectLogServiceSinkDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectLogServiceSinkDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectLogServiceSinkDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectLogServiceSinkDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2562,7 +2558,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkDeleteCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// Part of `sinkName`. The name of the sink to delete. - pub fn projects_id(mut self, new_value: &str) -> ProjectLogServiceSinkDeleteCall<'a, C, NC, A> { + pub fn projects_id(mut self, new_value: &str) -> ProjectLogServiceSinkDeleteCall<'a, C, A> { self._projects_id = new_value.to_string(); self } @@ -2572,7 +2568,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkDeleteCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// Part of `sinkName`. See documentation of `projectsId`. - pub fn log_services_id(mut self, new_value: &str) -> ProjectLogServiceSinkDeleteCall<'a, C, NC, A> { + pub fn log_services_id(mut self, new_value: &str) -> ProjectLogServiceSinkDeleteCall<'a, C, A> { self._log_services_id = new_value.to_string(); self } @@ -2582,7 +2578,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkDeleteCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// Part of `sinkName`. See documentation of `projectsId`. - pub fn sinks_id(mut self, new_value: &str) -> ProjectLogServiceSinkDeleteCall<'a, C, NC, A> { + pub fn sinks_id(mut self, new_value: &str) -> ProjectLogServiceSinkDeleteCall<'a, C, A> { self._sinks_id = new_value.to_string(); self } @@ -2593,7 +2589,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkDeleteCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogServiceSinkDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogServiceSinkDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2618,7 +2614,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkDeleteCall<'a, C, NC, A> where NC: hyper /// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. /// * *alt* (query-string) - Data format for response. /// * *$.xgafv* (query-string) - V1 error format. - pub fn param(mut self, name: T, value: T) -> ProjectLogServiceSinkDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectLogServiceSinkDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2635,7 +2631,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkDeleteCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectLogServiceSinkDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectLogServiceSinkDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2678,10 +2674,10 @@ impl<'a, C, NC, A> ProjectLogServiceSinkDeleteCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct ProjectLogServiceIndexeListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectLogServiceIndexeListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Logging, + hub: &'a Logging, _projects_id: String, _log_services_id: String, _page_token: Option, @@ -2694,9 +2690,9 @@ pub struct ProjectLogServiceIndexeListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectLogServiceIndexeListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectLogServiceIndexeListCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectLogServiceIndexeListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectLogServiceIndexeListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2844,7 +2840,7 @@ impl<'a, C, NC, A> ProjectLogServiceIndexeListCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// Part of `serviceName`. A log service resource of the form `/projects/*/logServices/*`. The service indexes of the log service are returned. Example: `"/projects/myProj/logServices/appengine.googleapis.com"`. - pub fn projects_id(mut self, new_value: &str) -> ProjectLogServiceIndexeListCall<'a, C, NC, A> { + pub fn projects_id(mut self, new_value: &str) -> ProjectLogServiceIndexeListCall<'a, C, A> { self._projects_id = new_value.to_string(); self } @@ -2854,7 +2850,7 @@ impl<'a, C, NC, A> ProjectLogServiceIndexeListCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// Part of `serviceName`. See documentation of `projectsId`. - pub fn log_services_id(mut self, new_value: &str) -> ProjectLogServiceIndexeListCall<'a, C, NC, A> { + pub fn log_services_id(mut self, new_value: &str) -> ProjectLogServiceIndexeListCall<'a, C, A> { self._log_services_id = new_value.to_string(); self } @@ -2862,7 +2858,7 @@ impl<'a, C, NC, A> ProjectLogServiceIndexeListCall<'a, C, NC, A> where NC: hyper /// /// /// An opaque token, returned as `nextPageToken` by a prior `ListLogServiceIndexes` operation. If `pageToken` is supplied, then the other fields of this request are ignored, and instead the previous `ListLogServiceIndexes` operation is continued. - pub fn page_token(mut self, new_value: &str) -> ProjectLogServiceIndexeListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ProjectLogServiceIndexeListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2870,7 +2866,7 @@ impl<'a, C, NC, A> ProjectLogServiceIndexeListCall<'a, C, NC, A> where NC: hyper /// /// /// The maximum number of log service index resources to return in one operation. - pub fn page_size(mut self, new_value: i32) -> ProjectLogServiceIndexeListCall<'a, C, NC, A> { + pub fn page_size(mut self, new_value: i32) -> ProjectLogServiceIndexeListCall<'a, C, A> { self._page_size = Some(new_value); self } @@ -2878,7 +2874,7 @@ impl<'a, C, NC, A> ProjectLogServiceIndexeListCall<'a, C, NC, A> where NC: hyper /// /// /// A log resource like `/projects/project_id/logs/log_name`, identifying the log for which to list service indexes. - pub fn log(mut self, new_value: &str) -> ProjectLogServiceIndexeListCall<'a, C, NC, A> { + pub fn log(mut self, new_value: &str) -> ProjectLogServiceIndexeListCall<'a, C, A> { self._log = Some(new_value.to_string()); self } @@ -2886,7 +2882,7 @@ impl<'a, C, NC, A> ProjectLogServiceIndexeListCall<'a, C, NC, A> where NC: hyper /// /// /// Restricts the indexes returned to be those with a specified prefix. The prefix has the form `"/label_value/label_value/..."`, in order corresponding to the [`LogService indexKeys`][google.logging.v1.LogService.index_keys]. Non-empty prefixes must begin with `/` . Example prefixes: + `"/myModule/"` retrieves App Engine versions associated with `myModule`. The trailing slash terminates the value. + `"/myModule"` retrieves App Engine modules with names beginning with `myModule`. + `""` retrieves all indexes. - pub fn index_prefix(mut self, new_value: &str) -> ProjectLogServiceIndexeListCall<'a, C, NC, A> { + pub fn index_prefix(mut self, new_value: &str) -> ProjectLogServiceIndexeListCall<'a, C, A> { self._index_prefix = Some(new_value.to_string()); self } @@ -2894,7 +2890,7 @@ impl<'a, C, NC, A> ProjectLogServiceIndexeListCall<'a, C, NC, A> where NC: hyper /// /// /// A limit to the number of levels of the index hierarchy that are expanded. If `depth` is 0, it defaults to the level specified by the prefix field (the number of slash separators). The default empty prefix implies a `depth` of 1. It is an error for `depth` to be any non-zero value less than the number of components in `indexPrefix`. - pub fn depth(mut self, new_value: i32) -> ProjectLogServiceIndexeListCall<'a, C, NC, A> { + pub fn depth(mut self, new_value: i32) -> ProjectLogServiceIndexeListCall<'a, C, A> { self._depth = Some(new_value); self } @@ -2905,7 +2901,7 @@ impl<'a, C, NC, A> ProjectLogServiceIndexeListCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogServiceIndexeListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogServiceIndexeListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2930,7 +2926,7 @@ impl<'a, C, NC, A> ProjectLogServiceIndexeListCall<'a, C, NC, A> where NC: hyper /// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. /// * *alt* (query-string) - Data format for response. /// * *$.xgafv* (query-string) - V1 error format. - pub fn param(mut self, name: T, value: T) -> ProjectLogServiceIndexeListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectLogServiceIndexeListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2947,7 +2943,7 @@ impl<'a, C, NC, A> ProjectLogServiceIndexeListCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectLogServiceIndexeListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectLogServiceIndexeListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2985,10 +2981,10 @@ impl<'a, C, NC, A> ProjectLogServiceIndexeListCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct ProjectLogSinkListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectLogSinkListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Logging, + hub: &'a Logging, _projects_id: String, _logs_id: String, _delegate: Option<&'a mut Delegate>, @@ -2996,9 +2992,9 @@ pub struct ProjectLogSinkListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectLogSinkListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectLogSinkListCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectLogSinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectLogSinkListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3131,7 +3127,7 @@ impl<'a, C, NC, A> ProjectLogSinkListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Part of `logName`. The log for which to list sinks. - pub fn projects_id(mut self, new_value: &str) -> ProjectLogSinkListCall<'a, C, NC, A> { + pub fn projects_id(mut self, new_value: &str) -> ProjectLogSinkListCall<'a, C, A> { self._projects_id = new_value.to_string(); self } @@ -3141,7 +3137,7 @@ impl<'a, C, NC, A> ProjectLogSinkListCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Part of `logName`. See documentation of `projectsId`. - pub fn logs_id(mut self, new_value: &str) -> ProjectLogSinkListCall<'a, C, NC, A> { + pub fn logs_id(mut self, new_value: &str) -> ProjectLogSinkListCall<'a, C, A> { self._logs_id = new_value.to_string(); self } @@ -3152,7 +3148,7 @@ impl<'a, C, NC, A> ProjectLogSinkListCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogSinkListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogSinkListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3177,7 +3173,7 @@ impl<'a, C, NC, A> ProjectLogSinkListCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. /// * *alt* (query-string) - Data format for response. /// * *$.xgafv* (query-string) - V1 error format. - pub fn param(mut self, name: T, value: T) -> ProjectLogSinkListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectLogSinkListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3194,7 +3190,7 @@ impl<'a, C, NC, A> ProjectLogSinkListCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectLogSinkListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectLogSinkListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3238,10 +3234,10 @@ impl<'a, C, NC, A> ProjectLogSinkListCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct ProjectLogSinkUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectLogSinkUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Logging, + hub: &'a Logging, _request: LogSink, _projects_id: String, _logs_id: String, @@ -3251,9 +3247,9 @@ pub struct ProjectLogSinkUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectLogSinkUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectLogSinkUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectLogSinkUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectLogSinkUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3394,7 +3390,7 @@ impl<'a, C, NC, A> ProjectLogSinkUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &LogSink) -> ProjectLogSinkUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &LogSink) -> ProjectLogSinkUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3404,7 +3400,7 @@ impl<'a, C, NC, A> ProjectLogSinkUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Part of `sinkName`. The name of the sink to update. - pub fn projects_id(mut self, new_value: &str) -> ProjectLogSinkUpdateCall<'a, C, NC, A> { + pub fn projects_id(mut self, new_value: &str) -> ProjectLogSinkUpdateCall<'a, C, A> { self._projects_id = new_value.to_string(); self } @@ -3414,7 +3410,7 @@ impl<'a, C, NC, A> ProjectLogSinkUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Part of `sinkName`. See documentation of `projectsId`. - pub fn logs_id(mut self, new_value: &str) -> ProjectLogSinkUpdateCall<'a, C, NC, A> { + pub fn logs_id(mut self, new_value: &str) -> ProjectLogSinkUpdateCall<'a, C, A> { self._logs_id = new_value.to_string(); self } @@ -3424,7 +3420,7 @@ impl<'a, C, NC, A> ProjectLogSinkUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Part of `sinkName`. See documentation of `projectsId`. - pub fn sinks_id(mut self, new_value: &str) -> ProjectLogSinkUpdateCall<'a, C, NC, A> { + pub fn sinks_id(mut self, new_value: &str) -> ProjectLogSinkUpdateCall<'a, C, A> { self._sinks_id = new_value.to_string(); self } @@ -3435,7 +3431,7 @@ impl<'a, C, NC, A> ProjectLogSinkUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogSinkUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogSinkUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3460,7 +3456,7 @@ impl<'a, C, NC, A> ProjectLogSinkUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. /// * *alt* (query-string) - Data format for response. /// * *$.xgafv* (query-string) - V1 error format. - pub fn param(mut self, name: T, value: T) -> ProjectLogSinkUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectLogSinkUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3477,7 +3473,7 @@ impl<'a, C, NC, A> ProjectLogSinkUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectLogSinkUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectLogSinkUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3521,10 +3517,10 @@ impl<'a, C, NC, A> ProjectLogSinkUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct ProjectLogServiceSinkCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectLogServiceSinkCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Logging, + hub: &'a Logging, _request: LogSink, _projects_id: String, _log_services_id: String, @@ -3533,9 +3529,9 @@ pub struct ProjectLogServiceSinkCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectLogServiceSinkCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectLogServiceSinkCreateCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectLogServiceSinkCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectLogServiceSinkCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3675,7 +3671,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkCreateCall<'a, C, NC, A> where NC: hyper /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &LogSink) -> ProjectLogServiceSinkCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &LogSink) -> ProjectLogServiceSinkCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3685,7 +3681,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkCreateCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// Part of `serviceName`. The name of the service in which to create a sink. - pub fn projects_id(mut self, new_value: &str) -> ProjectLogServiceSinkCreateCall<'a, C, NC, A> { + pub fn projects_id(mut self, new_value: &str) -> ProjectLogServiceSinkCreateCall<'a, C, A> { self._projects_id = new_value.to_string(); self } @@ -3695,7 +3691,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkCreateCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// Part of `serviceName`. See documentation of `projectsId`. - pub fn log_services_id(mut self, new_value: &str) -> ProjectLogServiceSinkCreateCall<'a, C, NC, A> { + pub fn log_services_id(mut self, new_value: &str) -> ProjectLogServiceSinkCreateCall<'a, C, A> { self._log_services_id = new_value.to_string(); self } @@ -3706,7 +3702,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkCreateCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogServiceSinkCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogServiceSinkCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3731,7 +3727,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkCreateCall<'a, C, NC, A> where NC: hyper /// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. /// * *alt* (query-string) - Data format for response. /// * *$.xgafv* (query-string) - V1 error format. - pub fn param(mut self, name: T, value: T) -> ProjectLogServiceSinkCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectLogServiceSinkCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3748,7 +3744,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkCreateCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectLogServiceSinkCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectLogServiceSinkCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3786,10 +3782,10 @@ impl<'a, C, NC, A> ProjectLogServiceSinkCreateCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct ProjectLogSinkDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectLogSinkDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Logging, + hub: &'a Logging, _projects_id: String, _logs_id: String, _sinks_id: String, @@ -3798,9 +3794,9 @@ pub struct ProjectLogSinkDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectLogSinkDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectLogSinkDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectLogSinkDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectLogSinkDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3934,7 +3930,7 @@ impl<'a, C, NC, A> ProjectLogSinkDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Part of `sinkName`. The name of the sink to delete. - pub fn projects_id(mut self, new_value: &str) -> ProjectLogSinkDeleteCall<'a, C, NC, A> { + pub fn projects_id(mut self, new_value: &str) -> ProjectLogSinkDeleteCall<'a, C, A> { self._projects_id = new_value.to_string(); self } @@ -3944,7 +3940,7 @@ impl<'a, C, NC, A> ProjectLogSinkDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Part of `sinkName`. See documentation of `projectsId`. - pub fn logs_id(mut self, new_value: &str) -> ProjectLogSinkDeleteCall<'a, C, NC, A> { + pub fn logs_id(mut self, new_value: &str) -> ProjectLogSinkDeleteCall<'a, C, A> { self._logs_id = new_value.to_string(); self } @@ -3954,7 +3950,7 @@ impl<'a, C, NC, A> ProjectLogSinkDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Part of `sinkName`. See documentation of `projectsId`. - pub fn sinks_id(mut self, new_value: &str) -> ProjectLogSinkDeleteCall<'a, C, NC, A> { + pub fn sinks_id(mut self, new_value: &str) -> ProjectLogSinkDeleteCall<'a, C, A> { self._sinks_id = new_value.to_string(); self } @@ -3965,7 +3961,7 @@ impl<'a, C, NC, A> ProjectLogSinkDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogSinkDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogSinkDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3990,7 +3986,7 @@ impl<'a, C, NC, A> ProjectLogSinkDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. /// * *alt* (query-string) - Data format for response. /// * *$.xgafv* (query-string) - V1 error format. - pub fn param(mut self, name: T, value: T) -> ProjectLogSinkDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectLogSinkDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4007,7 +4003,7 @@ impl<'a, C, NC, A> ProjectLogSinkDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectLogSinkDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectLogSinkDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4051,10 +4047,10 @@ impl<'a, C, NC, A> ProjectLogSinkDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct ProjectLogSinkCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectLogSinkCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Logging, + hub: &'a Logging, _request: LogSink, _projects_id: String, _logs_id: String, @@ -4063,9 +4059,9 @@ pub struct ProjectLogSinkCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectLogSinkCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectLogSinkCreateCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectLogSinkCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectLogSinkCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4205,7 +4201,7 @@ impl<'a, C, NC, A> ProjectLogSinkCreateCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &LogSink) -> ProjectLogSinkCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &LogSink) -> ProjectLogSinkCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4215,7 +4211,7 @@ impl<'a, C, NC, A> ProjectLogSinkCreateCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Part of `logName`. The log in which to create a sink resource. - pub fn projects_id(mut self, new_value: &str) -> ProjectLogSinkCreateCall<'a, C, NC, A> { + pub fn projects_id(mut self, new_value: &str) -> ProjectLogSinkCreateCall<'a, C, A> { self._projects_id = new_value.to_string(); self } @@ -4225,7 +4221,7 @@ impl<'a, C, NC, A> ProjectLogSinkCreateCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Part of `logName`. See documentation of `projectsId`. - pub fn logs_id(mut self, new_value: &str) -> ProjectLogSinkCreateCall<'a, C, NC, A> { + pub fn logs_id(mut self, new_value: &str) -> ProjectLogSinkCreateCall<'a, C, A> { self._logs_id = new_value.to_string(); self } @@ -4236,7 +4232,7 @@ impl<'a, C, NC, A> ProjectLogSinkCreateCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogSinkCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogSinkCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4261,7 +4257,7 @@ impl<'a, C, NC, A> ProjectLogSinkCreateCall<'a, C, NC, A> where NC: hyper::net:: /// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. /// * *alt* (query-string) - Data format for response. /// * *$.xgafv* (query-string) - V1 error format. - pub fn param(mut self, name: T, value: T) -> ProjectLogSinkCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectLogSinkCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4278,7 +4274,7 @@ impl<'a, C, NC, A> ProjectLogSinkCreateCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectLogSinkCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectLogSinkCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4316,10 +4312,10 @@ impl<'a, C, NC, A> ProjectLogSinkCreateCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct ProjectLogServiceSinkGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectLogServiceSinkGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Logging, + hub: &'a Logging, _projects_id: String, _log_services_id: String, _sinks_id: String, @@ -4328,9 +4324,9 @@ pub struct ProjectLogServiceSinkGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectLogServiceSinkGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectLogServiceSinkGetCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectLogServiceSinkGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectLogServiceSinkGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4464,7 +4460,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkGetCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Part of `sinkName`. The name of the sink to return. - pub fn projects_id(mut self, new_value: &str) -> ProjectLogServiceSinkGetCall<'a, C, NC, A> { + pub fn projects_id(mut self, new_value: &str) -> ProjectLogServiceSinkGetCall<'a, C, A> { self._projects_id = new_value.to_string(); self } @@ -4474,7 +4470,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkGetCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Part of `sinkName`. See documentation of `projectsId`. - pub fn log_services_id(mut self, new_value: &str) -> ProjectLogServiceSinkGetCall<'a, C, NC, A> { + pub fn log_services_id(mut self, new_value: &str) -> ProjectLogServiceSinkGetCall<'a, C, A> { self._log_services_id = new_value.to_string(); self } @@ -4484,7 +4480,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkGetCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Part of `sinkName`. See documentation of `projectsId`. - pub fn sinks_id(mut self, new_value: &str) -> ProjectLogServiceSinkGetCall<'a, C, NC, A> { + pub fn sinks_id(mut self, new_value: &str) -> ProjectLogServiceSinkGetCall<'a, C, A> { self._sinks_id = new_value.to_string(); self } @@ -4495,7 +4491,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkGetCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogServiceSinkGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogServiceSinkGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4520,7 +4516,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkGetCall<'a, C, NC, A> where NC: hyper::n /// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. /// * *alt* (query-string) - Data format for response. /// * *$.xgafv* (query-string) - V1 error format. - pub fn param(mut self, name: T, value: T) -> ProjectLogServiceSinkGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectLogServiceSinkGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4537,7 +4533,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkGetCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectLogServiceSinkGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectLogServiceSinkGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4575,10 +4571,10 @@ impl<'a, C, NC, A> ProjectLogServiceSinkGetCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct ProjectLogServiceSinkListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectLogServiceSinkListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Logging, + hub: &'a Logging, _projects_id: String, _log_services_id: String, _delegate: Option<&'a mut Delegate>, @@ -4586,9 +4582,9 @@ pub struct ProjectLogServiceSinkListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectLogServiceSinkListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectLogServiceSinkListCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectLogServiceSinkListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectLogServiceSinkListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4721,7 +4717,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkListCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Part of `serviceName`. The name of the service for which to list sinks. - pub fn projects_id(mut self, new_value: &str) -> ProjectLogServiceSinkListCall<'a, C, NC, A> { + pub fn projects_id(mut self, new_value: &str) -> ProjectLogServiceSinkListCall<'a, C, A> { self._projects_id = new_value.to_string(); self } @@ -4731,7 +4727,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkListCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Part of `serviceName`. See documentation of `projectsId`. - pub fn log_services_id(mut self, new_value: &str) -> ProjectLogServiceSinkListCall<'a, C, NC, A> { + pub fn log_services_id(mut self, new_value: &str) -> ProjectLogServiceSinkListCall<'a, C, A> { self._log_services_id = new_value.to_string(); self } @@ -4742,7 +4738,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkListCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogServiceSinkListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogServiceSinkListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4767,7 +4763,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkListCall<'a, C, NC, A> where NC: hyper:: /// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. /// * *alt* (query-string) - Data format for response. /// * *$.xgafv* (query-string) - V1 error format. - pub fn param(mut self, name: T, value: T) -> ProjectLogServiceSinkListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectLogServiceSinkListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4784,7 +4780,7 @@ impl<'a, C, NC, A> ProjectLogServiceSinkListCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectLogServiceSinkListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectLogServiceSinkListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4822,10 +4818,10 @@ impl<'a, C, NC, A> ProjectLogServiceSinkListCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct ProjectLogDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectLogDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Logging, + hub: &'a Logging, _projects_id: String, _logs_id: String, _delegate: Option<&'a mut Delegate>, @@ -4833,9 +4829,9 @@ pub struct ProjectLogDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectLogDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectLogDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectLogDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectLogDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4968,7 +4964,7 @@ impl<'a, C, NC, A> ProjectLogDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Part of `logName`. The log resource to delete. - pub fn projects_id(mut self, new_value: &str) -> ProjectLogDeleteCall<'a, C, NC, A> { + pub fn projects_id(mut self, new_value: &str) -> ProjectLogDeleteCall<'a, C, A> { self._projects_id = new_value.to_string(); self } @@ -4978,7 +4974,7 @@ impl<'a, C, NC, A> ProjectLogDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Part of `logName`. See documentation of `projectsId`. - pub fn logs_id(mut self, new_value: &str) -> ProjectLogDeleteCall<'a, C, NC, A> { + pub fn logs_id(mut self, new_value: &str) -> ProjectLogDeleteCall<'a, C, A> { self._logs_id = new_value.to_string(); self } @@ -4989,7 +4985,7 @@ impl<'a, C, NC, A> ProjectLogDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectLogDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5014,7 +5010,7 @@ impl<'a, C, NC, A> ProjectLogDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *key* (query-string) - API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. /// * *alt* (query-string) - Data format for response. /// * *$.xgafv* (query-string) - V1 error format. - pub fn param(mut self, name: T, value: T) -> ProjectLogDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectLogDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5031,7 +5027,7 @@ impl<'a, C, NC, A> ProjectLogDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectLogDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectLogDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/manager1_beta2/Cargo.toml b/gen/manager1_beta2/Cargo.toml index e8ffa050273..3fd6870003e 100644 --- a/gen/manager1_beta2/Cargo.toml +++ b/gen/manager1_beta2/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-manager1_beta2" -version = "0.1.4+20140915" +version = "0.1.5+20140915" authors = ["Sebastian Thiel "] description = "A complete library to interact with manager (protocol v1beta2)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/manager1_beta2" homepage = "https://developers.google.com/deployment-manager/" -documentation = "http://byron.github.io/google-apis-rs/google-manager1_beta2" +documentation = "http://byron.github.io/google-apis-rs/google_manager1_beta2" license = "MIT" keywords = ["manager", "google", "protocol", "web", "api"] diff --git a/gen/manager1_beta2/README.md b/gen/manager1_beta2/README.md index eaa1126f964..820ac25e9dc 100644 --- a/gen/manager1_beta2/README.md +++ b/gen/manager1_beta2/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-manager1_beta2` library allows access to all features of the *Google manager* service. -This documentation was generated from *manager* crate version *0.1.4+20140915*, where *20140915* is the exact revision of the *manager:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *manager* crate version *0.1.5+20140915*, where *20140915* is the exact revision of the *manager:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *manager* *v1_beta2* API can be found at the [official documentation site](https://developers.google.com/deployment-manager/). diff --git a/gen/manager1_beta2/src/cmn.rs b/gen/manager1_beta2/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/manager1_beta2/src/cmn.rs +++ b/gen/manager1_beta2/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/manager1_beta2/src/lib.rs b/gen/manager1_beta2/src/lib.rs index a7171c5ef97..959008264df 100644 --- a/gen/manager1_beta2/src/lib.rs +++ b/gen/manager1_beta2/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *manager* crate version *0.1.4+20140915*, where *20140915* is the exact revision of the *manager:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *manager* crate version *0.1.5+20140915*, where *20140915* is the exact revision of the *manager:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *manager* *v1_beta2* API can be found at the //! [official documentation site](https://developers.google.com/deployment-manager/). @@ -195,7 +195,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -308,37 +307,34 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Manager { +pub struct Manager { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Manager {} +impl<'a, C, A> Hub for Manager {} -impl<'a, C, NC, A> Manager - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Manager + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Manager { + pub fn new(client: C, authenticator: A) -> Manager { Manager { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn deployments(&'a self) -> DeploymentMethods<'a, C, NC, A> { + pub fn deployments(&'a self) -> DeploymentMethods<'a, C, A> { DeploymentMethods { hub: &self } } - pub fn templates(&'a self) -> TemplateMethods<'a, C, NC, A> { + pub fn templates(&'a self) -> TemplateMethods<'a, C, A> { TemplateMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -1133,15 +1129,15 @@ impl Part for DiskAttachment {} /// let rb = hub.templates(); /// # } /// ``` -pub struct TemplateMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TemplateMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Manager, + hub: &'a Manager, } -impl<'a, C, NC, A> MethodsBuilder for TemplateMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TemplateMethods<'a, C, A> {} -impl<'a, C, NC, A> TemplateMethods<'a, C, NC, A> { +impl<'a, C, A> TemplateMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1150,7 +1146,7 @@ impl<'a, C, NC, A> TemplateMethods<'a, C, NC, A> { /// # Arguments /// /// * `projectId` - No description provided. - pub fn list(&self, project_id: &str) -> TemplateListCall<'a, C, NC, A> { + pub fn list(&self, project_id: &str) -> TemplateListCall<'a, C, A> { TemplateListCall { hub: self.hub, _project_id: project_id.to_string(), @@ -1170,7 +1166,7 @@ impl<'a, C, NC, A> TemplateMethods<'a, C, NC, A> { /// /// * `projectId` - No description provided. /// * `templateName` - No description provided. - pub fn delete(&self, project_id: &str, template_name: &str) -> TemplateDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project_id: &str, template_name: &str) -> TemplateDeleteCall<'a, C, A> { TemplateDeleteCall { hub: self.hub, _project_id: project_id.to_string(), @@ -1189,7 +1185,7 @@ impl<'a, C, NC, A> TemplateMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `projectId` - No description provided. - pub fn insert(&self, request: &Template, project_id: &str) -> TemplateInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Template, project_id: &str) -> TemplateInsertCall<'a, C, A> { TemplateInsertCall { hub: self.hub, _request: request.clone(), @@ -1208,7 +1204,7 @@ impl<'a, C, NC, A> TemplateMethods<'a, C, NC, A> { /// /// * `projectId` - No description provided. /// * `templateName` - No description provided. - pub fn get(&self, project_id: &str, template_name: &str) -> TemplateGetCall<'a, C, NC, A> { + pub fn get(&self, project_id: &str, template_name: &str) -> TemplateGetCall<'a, C, A> { TemplateGetCall { hub: self.hub, _project_id: project_id.to_string(), @@ -1250,15 +1246,15 @@ impl<'a, C, NC, A> TemplateMethods<'a, C, NC, A> { /// let rb = hub.deployments(); /// # } /// ``` -pub struct DeploymentMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DeploymentMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Manager, + hub: &'a Manager, } -impl<'a, C, NC, A> MethodsBuilder for DeploymentMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for DeploymentMethods<'a, C, A> {} -impl<'a, C, NC, A> DeploymentMethods<'a, C, NC, A> { +impl<'a, C, A> DeploymentMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1269,7 +1265,7 @@ impl<'a, C, NC, A> DeploymentMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `projectId` - No description provided. /// * `region` - No description provided. - pub fn insert(&self, request: &Deployment, project_id: &str, region: &str) -> DeploymentInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Deployment, project_id: &str, region: &str) -> DeploymentInsertCall<'a, C, A> { DeploymentInsertCall { hub: self.hub, _request: request.clone(), @@ -1290,7 +1286,7 @@ impl<'a, C, NC, A> DeploymentMethods<'a, C, NC, A> { /// * `projectId` - No description provided. /// * `region` - No description provided. /// * `deploymentName` - No description provided. - pub fn get(&self, project_id: &str, region: &str, deployment_name: &str) -> DeploymentGetCall<'a, C, NC, A> { + pub fn get(&self, project_id: &str, region: &str, deployment_name: &str) -> DeploymentGetCall<'a, C, A> { DeploymentGetCall { hub: self.hub, _project_id: project_id.to_string(), @@ -1310,7 +1306,7 @@ impl<'a, C, NC, A> DeploymentMethods<'a, C, NC, A> { /// /// * `projectId` - No description provided. /// * `region` - No description provided. - pub fn list(&self, project_id: &str, region: &str) -> DeploymentListCall<'a, C, NC, A> { + pub fn list(&self, project_id: &str, region: &str) -> DeploymentListCall<'a, C, A> { DeploymentListCall { hub: self.hub, _project_id: project_id.to_string(), @@ -1332,7 +1328,7 @@ impl<'a, C, NC, A> DeploymentMethods<'a, C, NC, A> { /// * `projectId` - No description provided. /// * `region` - No description provided. /// * `deploymentName` - No description provided. - pub fn delete(&self, project_id: &str, region: &str, deployment_name: &str) -> DeploymentDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project_id: &str, region: &str, deployment_name: &str) -> DeploymentDeleteCall<'a, C, A> { DeploymentDeleteCall { hub: self.hub, _project_id: project_id.to_string(), @@ -1385,10 +1381,10 @@ impl<'a, C, NC, A> DeploymentMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct TemplateListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TemplateListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Manager, + hub: &'a Manager, _project_id: String, _page_token: Option, _max_results: Option, @@ -1397,9 +1393,9 @@ pub struct TemplateListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TemplateListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TemplateListCall<'a, C, A> {} -impl<'a, C, NC, A> TemplateListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TemplateListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1536,7 +1532,7 @@ impl<'a, C, NC, A> TemplateListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn project_id(mut self, new_value: &str) -> TemplateListCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> TemplateListCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -1544,7 +1540,7 @@ impl<'a, C, NC, A> TemplateListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Specifies a nextPageToken returned by a previous list request. This token can be used to request the next page of results from a previous list request. - pub fn page_token(mut self, new_value: &str) -> TemplateListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TemplateListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -1552,7 +1548,7 @@ impl<'a, C, NC, A> TemplateListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Maximum count of results to be returned. Acceptable values are 0 to 100, inclusive. (Default: 50) - pub fn max_results(mut self, new_value: i32) -> TemplateListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> TemplateListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -1563,7 +1559,7 @@ impl<'a, C, NC, A> TemplateListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TemplateListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TemplateListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1584,7 +1580,7 @@ impl<'a, C, NC, A> TemplateListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TemplateListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TemplateListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1601,7 +1597,7 @@ impl<'a, C, NC, A> TemplateListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TemplateListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TemplateListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1639,10 +1635,10 @@ impl<'a, C, NC, A> TemplateListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct TemplateDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TemplateDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Manager, + hub: &'a Manager, _project_id: String, _template_name: String, _delegate: Option<&'a mut Delegate>, @@ -1650,9 +1646,9 @@ pub struct TemplateDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TemplateDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TemplateDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> TemplateDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TemplateDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1773,7 +1769,7 @@ impl<'a, C, NC, A> TemplateDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn project_id(mut self, new_value: &str) -> TemplateDeleteCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> TemplateDeleteCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -1782,7 +1778,7 @@ impl<'a, C, NC, A> TemplateDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn template_name(mut self, new_value: &str) -> TemplateDeleteCall<'a, C, NC, A> { + pub fn template_name(mut self, new_value: &str) -> TemplateDeleteCall<'a, C, A> { self._template_name = new_value.to_string(); self } @@ -1793,7 +1789,7 @@ impl<'a, C, NC, A> TemplateDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TemplateDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TemplateDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1814,7 +1810,7 @@ impl<'a, C, NC, A> TemplateDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TemplateDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TemplateDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1831,7 +1827,7 @@ impl<'a, C, NC, A> TemplateDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TemplateDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TemplateDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1875,10 +1871,10 @@ impl<'a, C, NC, A> TemplateDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct TemplateInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TemplateInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Manager, + hub: &'a Manager, _request: Template, _project_id: String, _delegate: Option<&'a mut Delegate>, @@ -1886,9 +1882,9 @@ pub struct TemplateInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TemplateInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TemplateInsertCall<'a, C, A> {} -impl<'a, C, NC, A> TemplateInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TemplateInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2027,7 +2023,7 @@ impl<'a, C, NC, A> TemplateInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Template) -> TemplateInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Template) -> TemplateInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2036,7 +2032,7 @@ impl<'a, C, NC, A> TemplateInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn project_id(mut self, new_value: &str) -> TemplateInsertCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> TemplateInsertCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -2047,7 +2043,7 @@ impl<'a, C, NC, A> TemplateInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TemplateInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TemplateInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2068,7 +2064,7 @@ impl<'a, C, NC, A> TemplateInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TemplateInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TemplateInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2085,7 +2081,7 @@ impl<'a, C, NC, A> TemplateInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TemplateInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TemplateInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2123,10 +2119,10 @@ impl<'a, C, NC, A> TemplateInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct TemplateGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TemplateGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Manager, + hub: &'a Manager, _project_id: String, _template_name: String, _delegate: Option<&'a mut Delegate>, @@ -2134,9 +2130,9 @@ pub struct TemplateGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TemplateGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TemplateGetCall<'a, C, A> {} -impl<'a, C, NC, A> TemplateGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TemplateGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2268,7 +2264,7 @@ impl<'a, C, NC, A> TemplateGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn project_id(mut self, new_value: &str) -> TemplateGetCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> TemplateGetCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -2277,7 +2273,7 @@ impl<'a, C, NC, A> TemplateGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn template_name(mut self, new_value: &str) -> TemplateGetCall<'a, C, NC, A> { + pub fn template_name(mut self, new_value: &str) -> TemplateGetCall<'a, C, A> { self._template_name = new_value.to_string(); self } @@ -2288,7 +2284,7 @@ impl<'a, C, NC, A> TemplateGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TemplateGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TemplateGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2309,7 +2305,7 @@ impl<'a, C, NC, A> TemplateGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TemplateGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TemplateGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2326,7 +2322,7 @@ impl<'a, C, NC, A> TemplateGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TemplateGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TemplateGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2370,10 +2366,10 @@ impl<'a, C, NC, A> TemplateGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct DeploymentInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DeploymentInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Manager, + hub: &'a Manager, _request: Deployment, _project_id: String, _region: String, @@ -2382,9 +2378,9 @@ pub struct DeploymentInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DeploymentInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DeploymentInsertCall<'a, C, A> {} -impl<'a, C, NC, A> DeploymentInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DeploymentInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2524,7 +2520,7 @@ impl<'a, C, NC, A> DeploymentInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Deployment) -> DeploymentInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Deployment) -> DeploymentInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2533,7 +2529,7 @@ impl<'a, C, NC, A> DeploymentInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn project_id(mut self, new_value: &str) -> DeploymentInsertCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> DeploymentInsertCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -2542,7 +2538,7 @@ impl<'a, C, NC, A> DeploymentInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn region(mut self, new_value: &str) -> DeploymentInsertCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> DeploymentInsertCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -2553,7 +2549,7 @@ impl<'a, C, NC, A> DeploymentInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeploymentInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeploymentInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2574,7 +2570,7 @@ impl<'a, C, NC, A> DeploymentInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DeploymentInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DeploymentInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2591,7 +2587,7 @@ impl<'a, C, NC, A> DeploymentInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DeploymentInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DeploymentInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2629,10 +2625,10 @@ impl<'a, C, NC, A> DeploymentInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct DeploymentGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DeploymentGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Manager, + hub: &'a Manager, _project_id: String, _region: String, _deployment_name: String, @@ -2641,9 +2637,9 @@ pub struct DeploymentGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DeploymentGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DeploymentGetCall<'a, C, A> {} -impl<'a, C, NC, A> DeploymentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DeploymentGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2776,7 +2772,7 @@ impl<'a, C, NC, A> DeploymentGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn project_id(mut self, new_value: &str) -> DeploymentGetCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> DeploymentGetCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -2785,7 +2781,7 @@ impl<'a, C, NC, A> DeploymentGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn region(mut self, new_value: &str) -> DeploymentGetCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> DeploymentGetCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -2794,7 +2790,7 @@ impl<'a, C, NC, A> DeploymentGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn deployment_name(mut self, new_value: &str) -> DeploymentGetCall<'a, C, NC, A> { + pub fn deployment_name(mut self, new_value: &str) -> DeploymentGetCall<'a, C, A> { self._deployment_name = new_value.to_string(); self } @@ -2805,7 +2801,7 @@ impl<'a, C, NC, A> DeploymentGetCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeploymentGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeploymentGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2826,7 +2822,7 @@ impl<'a, C, NC, A> DeploymentGetCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DeploymentGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DeploymentGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2843,7 +2839,7 @@ impl<'a, C, NC, A> DeploymentGetCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DeploymentGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DeploymentGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2883,10 +2879,10 @@ impl<'a, C, NC, A> DeploymentGetCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct DeploymentListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DeploymentListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Manager, + hub: &'a Manager, _project_id: String, _region: String, _page_token: Option, @@ -2896,9 +2892,9 @@ pub struct DeploymentListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DeploymentListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DeploymentListCall<'a, C, A> {} -impl<'a, C, NC, A> DeploymentListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DeploymentListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3036,7 +3032,7 @@ impl<'a, C, NC, A> DeploymentListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn project_id(mut self, new_value: &str) -> DeploymentListCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> DeploymentListCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -3045,7 +3041,7 @@ impl<'a, C, NC, A> DeploymentListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn region(mut self, new_value: &str) -> DeploymentListCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> DeploymentListCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -3053,7 +3049,7 @@ impl<'a, C, NC, A> DeploymentListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Specifies a nextPageToken returned by a previous list request. This token can be used to request the next page of results from a previous list request. - pub fn page_token(mut self, new_value: &str) -> DeploymentListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> DeploymentListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -3061,7 +3057,7 @@ impl<'a, C, NC, A> DeploymentListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Maximum count of results to be returned. Acceptable values are 0 to 100, inclusive. (Default: 50) - pub fn max_results(mut self, new_value: i32) -> DeploymentListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> DeploymentListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -3072,7 +3068,7 @@ impl<'a, C, NC, A> DeploymentListCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeploymentListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeploymentListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3093,7 +3089,7 @@ impl<'a, C, NC, A> DeploymentListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DeploymentListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DeploymentListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3110,7 +3106,7 @@ impl<'a, C, NC, A> DeploymentListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DeploymentListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DeploymentListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3148,10 +3144,10 @@ impl<'a, C, NC, A> DeploymentListCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct DeploymentDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DeploymentDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Manager, + hub: &'a Manager, _project_id: String, _region: String, _deployment_name: String, @@ -3160,9 +3156,9 @@ pub struct DeploymentDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DeploymentDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DeploymentDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> DeploymentDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DeploymentDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3284,7 +3280,7 @@ impl<'a, C, NC, A> DeploymentDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn project_id(mut self, new_value: &str) -> DeploymentDeleteCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> DeploymentDeleteCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -3293,7 +3289,7 @@ impl<'a, C, NC, A> DeploymentDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn region(mut self, new_value: &str) -> DeploymentDeleteCall<'a, C, NC, A> { + pub fn region(mut self, new_value: &str) -> DeploymentDeleteCall<'a, C, A> { self._region = new_value.to_string(); self } @@ -3302,7 +3298,7 @@ impl<'a, C, NC, A> DeploymentDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn deployment_name(mut self, new_value: &str) -> DeploymentDeleteCall<'a, C, NC, A> { + pub fn deployment_name(mut self, new_value: &str) -> DeploymentDeleteCall<'a, C, A> { self._deployment_name = new_value.to_string(); self } @@ -3313,7 +3309,7 @@ impl<'a, C, NC, A> DeploymentDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeploymentDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeploymentDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3334,7 +3330,7 @@ impl<'a, C, NC, A> DeploymentDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DeploymentDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DeploymentDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3351,7 +3347,7 @@ impl<'a, C, NC, A> DeploymentDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DeploymentDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DeploymentDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/mapsengine1/Cargo.toml b/gen/mapsengine1/Cargo.toml index da168d64949..3263d2e2223 100644 --- a/gen/mapsengine1/Cargo.toml +++ b/gen/mapsengine1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-mapsengine1" -version = "0.1.4+20150225" +version = "0.1.5+20150225" authors = ["Sebastian Thiel "] description = "A complete library to interact with Maps Engine (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/mapsengine1" homepage = "https://developers.google.com/maps-engine/" -documentation = "http://byron.github.io/google-apis-rs/google-mapsengine1" +documentation = "http://byron.github.io/google-apis-rs/google_mapsengine1" license = "MIT" keywords = ["mapsengine", "google", "protocol", "web", "api"] diff --git a/gen/mapsengine1/README.md b/gen/mapsengine1/README.md index 369581764fd..08d61d50b1d 100644 --- a/gen/mapsengine1/README.md +++ b/gen/mapsengine1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-mapsengine1` library allows access to all features of the *Google Maps Engine* service. -This documentation was generated from *Maps Engine* crate version *0.1.4+20150225*, where *20150225* is the exact revision of the *mapsengine:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *Maps Engine* crate version *0.1.5+20150225*, where *20150225* is the exact revision of the *mapsengine:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *Maps Engine* *v1* API can be found at the [official documentation site](https://developers.google.com/maps-engine/). diff --git a/gen/mapsengine1/src/cmn.rs b/gen/mapsengine1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/mapsengine1/src/cmn.rs +++ b/gen/mapsengine1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/mapsengine1/src/lib.rs b/gen/mapsengine1/src/lib.rs index 3230e858dbf..dd74f5dd9fc 100644 --- a/gen/mapsengine1/src/lib.rs +++ b/gen/mapsengine1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *Maps Engine* crate version *0.1.4+20150225*, where *20150225* is the exact revision of the *mapsengine:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *Maps Engine* crate version *0.1.5+20150225*, where *20150225* is the exact revision of the *mapsengine:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *Maps Engine* *v1* API can be found at the //! [official documentation site](https://developers.google.com/maps-engine/). @@ -239,7 +239,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -347,52 +346,49 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct MapsEngine { +pub struct MapsEngine { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for MapsEngine {} +impl<'a, C, A> Hub for MapsEngine {} -impl<'a, C, NC, A> MapsEngine - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MapsEngine + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> MapsEngine { + pub fn new(client: C, authenticator: A) -> MapsEngine { MapsEngine { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn assets(&'a self) -> AssetMethods<'a, C, NC, A> { + pub fn assets(&'a self) -> AssetMethods<'a, C, A> { AssetMethods { hub: &self } } - pub fn layers(&'a self) -> LayerMethods<'a, C, NC, A> { + pub fn layers(&'a self) -> LayerMethods<'a, C, A> { LayerMethods { hub: &self } } - pub fn maps(&'a self) -> MapMethods<'a, C, NC, A> { + pub fn maps(&'a self) -> MapMethods<'a, C, A> { MapMethods { hub: &self } } - pub fn projects(&'a self) -> ProjectMethods<'a, C, NC, A> { + pub fn projects(&'a self) -> ProjectMethods<'a, C, A> { ProjectMethods { hub: &self } } - pub fn raster_collections(&'a self) -> RasterCollectionMethods<'a, C, NC, A> { + pub fn raster_collections(&'a self) -> RasterCollectionMethods<'a, C, A> { RasterCollectionMethods { hub: &self } } - pub fn rasters(&'a self) -> RasterMethods<'a, C, NC, A> { + pub fn rasters(&'a self) -> RasterMethods<'a, C, A> { RasterMethods { hub: &self } } - pub fn tables(&'a self) -> TableMethods<'a, C, NC, A> { + pub fn tables(&'a self) -> TableMethods<'a, C, A> { TableMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -2346,15 +2342,15 @@ impl Part for Datasource {} /// let rb = hub.layers(); /// # } /// ``` -pub struct LayerMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LayerMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, } -impl<'a, C, NC, A> MethodsBuilder for LayerMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for LayerMethods<'a, C, A> {} -impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { +impl<'a, C, A> LayerMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2363,7 +2359,7 @@ impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the layer. - pub fn unpublish(&self, id: &str) -> LayerUnpublishCall<'a, C, NC, A> { + pub fn unpublish(&self, id: &str) -> LayerUnpublishCall<'a, C, A> { LayerUnpublishCall { hub: self.hub, _id: id.to_string(), @@ -2380,7 +2376,7 @@ impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the layer. - pub fn publish(&self, id: &str) -> LayerPublishCall<'a, C, NC, A> { + pub fn publish(&self, id: &str) -> LayerPublishCall<'a, C, A> { LayerPublishCall { hub: self.hub, _id: id.to_string(), @@ -2394,7 +2390,7 @@ impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Return all published layers readable by the current user. - pub fn list_published(&self) -> LayerListPublishedCall<'a, C, NC, A> { + pub fn list_published(&self) -> LayerListPublishedCall<'a, C, A> { LayerListPublishedCall { hub: self.hub, _project_id: Default::default(), @@ -2413,7 +2409,7 @@ impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn create(&self, request: &Layer) -> LayerCreateCall<'a, C, NC, A> { + pub fn create(&self, request: &Layer) -> LayerCreateCall<'a, C, A> { LayerCreateCall { hub: self.hub, _request: request.clone(), @@ -2431,7 +2427,7 @@ impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the layer. - pub fn get_published(&self, id: &str) -> LayerGetPublishedCall<'a, C, NC, A> { + pub fn get_published(&self, id: &str) -> LayerGetPublishedCall<'a, C, A> { LayerGetPublishedCall { hub: self.hub, _id: id.to_string(), @@ -2448,7 +2444,7 @@ impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the layer. Only the layer creator or project owner are permitted to delete. If the layer is published, or included in a map, the request will fail. Unpublish the layer, and remove it from all maps prior to deleting. - pub fn delete(&self, id: &str) -> LayerDeleteCall<'a, C, NC, A> { + pub fn delete(&self, id: &str) -> LayerDeleteCall<'a, C, A> { LayerDeleteCall { hub: self.hub, _id: id.to_string(), @@ -2465,7 +2461,7 @@ impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the layer. - pub fn get(&self, id: &str) -> LayerGetCall<'a, C, NC, A> { + pub fn get(&self, id: &str) -> LayerGetCall<'a, C, A> { LayerGetCall { hub: self.hub, _id: id.to_string(), @@ -2484,7 +2480,7 @@ impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the asset from which permissions will be removed. - pub fn permissions_batch_delete(&self, request: &PermissionsBatchDeleteRequest, id: &str) -> LayerPermissionBatchDeleteCall<'a, C, NC, A> { + pub fn permissions_batch_delete(&self, request: &PermissionsBatchDeleteRequest, id: &str) -> LayerPermissionBatchDeleteCall<'a, C, A> { LayerPermissionBatchDeleteCall { hub: self.hub, _request: request.clone(), @@ -2505,7 +2501,7 @@ impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the asset to which permissions will be added. - pub fn permissions_batch_update(&self, request: &PermissionsBatchUpdateRequest, id: &str) -> LayerPermissionBatchUpdateCall<'a, C, NC, A> { + pub fn permissions_batch_update(&self, request: &PermissionsBatchUpdateRequest, id: &str) -> LayerPermissionBatchUpdateCall<'a, C, A> { LayerPermissionBatchUpdateCall { hub: self.hub, _request: request.clone(), @@ -2519,7 +2515,7 @@ impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Return all layers readable by the current user. - pub fn list(&self) -> LayerListCall<'a, C, NC, A> { + pub fn list(&self) -> LayerListCall<'a, C, A> { LayerListCall { hub: self.hub, _tags: Default::default(), @@ -2548,7 +2544,7 @@ impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the layer whose parents will be listed. - pub fn parents_list(&self, id: &str) -> LayerParentListCall<'a, C, NC, A> { + pub fn parents_list(&self, id: &str) -> LayerParentListCall<'a, C, A> { LayerParentListCall { hub: self.hub, _id: id.to_string(), @@ -2567,7 +2563,7 @@ impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the layer. - pub fn cancel_processing(&self, id: &str) -> LayerCancelProcessingCall<'a, C, NC, A> { + pub fn cancel_processing(&self, id: &str) -> LayerCancelProcessingCall<'a, C, A> { LayerCancelProcessingCall { hub: self.hub, _id: id.to_string(), @@ -2585,7 +2581,7 @@ impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the layer. - pub fn patch(&self, request: &Layer, id: &str) -> LayerPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Layer, id: &str) -> LayerPatchCall<'a, C, A> { LayerPatchCall { hub: self.hub, _request: request.clone(), @@ -2603,7 +2599,7 @@ impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the asset whose permissions will be listed. - pub fn permissions_list(&self, id: &str) -> LayerPermissionListCall<'a, C, NC, A> { + pub fn permissions_list(&self, id: &str) -> LayerPermissionListCall<'a, C, A> { LayerPermissionListCall { hub: self.hub, _id: id.to_string(), @@ -2620,7 +2616,7 @@ impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the layer. - pub fn process(&self, id: &str) -> LayerProcesCall<'a, C, NC, A> { + pub fn process(&self, id: &str) -> LayerProcesCall<'a, C, A> { LayerProcesCall { hub: self.hub, _id: id.to_string(), @@ -2661,15 +2657,15 @@ impl<'a, C, NC, A> LayerMethods<'a, C, NC, A> { /// let rb = hub.rasters(); /// # } /// ``` -pub struct RasterMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, } -impl<'a, C, NC, A> MethodsBuilder for RasterMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for RasterMethods<'a, C, A> {} -impl<'a, C, NC, A> RasterMethods<'a, C, NC, A> { +impl<'a, C, A> RasterMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2681,7 +2677,7 @@ impl<'a, C, NC, A> RasterMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the asset to which permissions will be added. - pub fn permissions_batch_update(&self, request: &PermissionsBatchUpdateRequest, id: &str) -> RasterPermissionBatchUpdateCall<'a, C, NC, A> { + pub fn permissions_batch_update(&self, request: &PermissionsBatchUpdateRequest, id: &str) -> RasterPermissionBatchUpdateCall<'a, C, A> { RasterPermissionBatchUpdateCall { hub: self.hub, _request: request.clone(), @@ -2700,7 +2696,7 @@ impl<'a, C, NC, A> RasterMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the raster. - pub fn patch(&self, request: &Raster, id: &str) -> RasterPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Raster, id: &str) -> RasterPatchCall<'a, C, A> { RasterPatchCall { hub: self.hub, _request: request.clone(), @@ -2718,7 +2714,7 @@ impl<'a, C, NC, A> RasterMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the asset whose permissions will be listed. - pub fn permissions_list(&self, id: &str) -> RasterPermissionListCall<'a, C, NC, A> { + pub fn permissions_list(&self, id: &str) -> RasterPermissionListCall<'a, C, A> { RasterPermissionListCall { hub: self.hub, _id: id.to_string(), @@ -2735,7 +2731,7 @@ impl<'a, C, NC, A> RasterMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the raster. Only the raster creator or project owner are permitted to delete. If the raster is included in a layer or mosaic, the request will fail. Remove it from all parents prior to deleting. - pub fn delete(&self, id: &str) -> RasterDeleteCall<'a, C, NC, A> { + pub fn delete(&self, id: &str) -> RasterDeleteCall<'a, C, A> { RasterDeleteCall { hub: self.hub, _id: id.to_string(), @@ -2753,7 +2749,7 @@ impl<'a, C, NC, A> RasterMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the asset from which permissions will be removed. - pub fn permissions_batch_delete(&self, request: &PermissionsBatchDeleteRequest, id: &str) -> RasterPermissionBatchDeleteCall<'a, C, NC, A> { + pub fn permissions_batch_delete(&self, request: &PermissionsBatchDeleteRequest, id: &str) -> RasterPermissionBatchDeleteCall<'a, C, A> { RasterPermissionBatchDeleteCall { hub: self.hub, _request: request.clone(), @@ -2772,7 +2768,7 @@ impl<'a, C, NC, A> RasterMethods<'a, C, NC, A> { /// /// * `id` - The ID of the raster asset. /// * `filename` - The file name of this uploaded file. - pub fn files_insert(&self, id: &str, filename: &str) -> RasterFileInsertCall<'a, C, NC, A> { + pub fn files_insert(&self, id: &str, filename: &str) -> RasterFileInsertCall<'a, C, A> { RasterFileInsertCall { hub: self.hub, _id: id.to_string(), @@ -2790,7 +2786,7 @@ impl<'a, C, NC, A> RasterMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the raster. - pub fn process(&self, id: &str) -> RasterProcesCall<'a, C, NC, A> { + pub fn process(&self, id: &str) -> RasterProcesCall<'a, C, A> { RasterProcesCall { hub: self.hub, _id: id.to_string(), @@ -2807,7 +2803,7 @@ impl<'a, C, NC, A> RasterMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the raster. - pub fn get(&self, id: &str) -> RasterGetCall<'a, C, NC, A> { + pub fn get(&self, id: &str) -> RasterGetCall<'a, C, A> { RasterGetCall { hub: self.hub, _id: id.to_string(), @@ -2824,7 +2820,7 @@ impl<'a, C, NC, A> RasterMethods<'a, C, NC, A> { /// # Arguments /// /// * `projectId` - The ID of a Maps Engine project, used to filter the response. To list all available projects with their IDs, send a Projects: list request. You can also find your project ID as the value of the DashboardPlace:cid URL parameter when signed in to mapsengine.google.com. - pub fn list(&self, project_id: &str) -> RasterListCall<'a, C, NC, A> { + pub fn list(&self, project_id: &str) -> RasterListCall<'a, C, A> { RasterListCall { hub: self.hub, _project_id: project_id.to_string(), @@ -2853,7 +2849,7 @@ impl<'a, C, NC, A> RasterMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn upload(&self, request: &Raster) -> RasterUploadCall<'a, C, NC, A> { + pub fn upload(&self, request: &Raster) -> RasterUploadCall<'a, C, A> { RasterUploadCall { hub: self.hub, _request: request.clone(), @@ -2870,7 +2866,7 @@ impl<'a, C, NC, A> RasterMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the rasters whose parents will be listed. - pub fn parents_list(&self, id: &str) -> RasterParentListCall<'a, C, NC, A> { + pub fn parents_list(&self, id: &str) -> RasterParentListCall<'a, C, A> { RasterParentListCall { hub: self.hub, _id: id.to_string(), @@ -2913,15 +2909,15 @@ impl<'a, C, NC, A> RasterMethods<'a, C, NC, A> { /// let rb = hub.assets(); /// # } /// ``` -pub struct AssetMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AssetMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, } -impl<'a, C, NC, A> MethodsBuilder for AssetMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AssetMethods<'a, C, A> {} -impl<'a, C, NC, A> AssetMethods<'a, C, NC, A> { +impl<'a, C, A> AssetMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2930,7 +2926,7 @@ impl<'a, C, NC, A> AssetMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the asset whose permissions will be listed. - pub fn permissions_list(&self, id: &str) -> AssetPermissionListCall<'a, C, NC, A> { + pub fn permissions_list(&self, id: &str) -> AssetPermissionListCall<'a, C, A> { AssetPermissionListCall { hub: self.hub, _id: id.to_string(), @@ -2943,7 +2939,7 @@ impl<'a, C, NC, A> AssetMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Return all assets readable by the current user. - pub fn list(&self) -> AssetListCall<'a, C, NC, A> { + pub fn list(&self) -> AssetListCall<'a, C, A> { AssetListCall { hub: self.hub, _type_: Default::default(), @@ -2972,7 +2968,7 @@ impl<'a, C, NC, A> AssetMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the asset. - pub fn get(&self, id: &str) -> AssetGetCall<'a, C, NC, A> { + pub fn get(&self, id: &str) -> AssetGetCall<'a, C, A> { AssetGetCall { hub: self.hub, _id: id.to_string(), @@ -2989,7 +2985,7 @@ impl<'a, C, NC, A> AssetMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the asset whose parents will be listed. - pub fn parents_list(&self, id: &str) -> AssetParentListCall<'a, C, NC, A> { + pub fn parents_list(&self, id: &str) -> AssetParentListCall<'a, C, A> { AssetParentListCall { hub: self.hub, _id: id.to_string(), @@ -3032,15 +3028,15 @@ impl<'a, C, NC, A> AssetMethods<'a, C, NC, A> { /// let rb = hub.tables(); /// # } /// ``` -pub struct TableMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, } -impl<'a, C, NC, A> MethodsBuilder for TableMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TableMethods<'a, C, A> {} -impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { +impl<'a, C, A> TableMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3049,7 +3045,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the table. Only the table creator or project owner are permitted to delete. If the table is included in a layer, the request will fail. Remove it from all layers prior to deleting. - pub fn delete(&self, id: &str) -> TableDeleteCall<'a, C, NC, A> { + pub fn delete(&self, id: &str) -> TableDeleteCall<'a, C, A> { TableDeleteCall { hub: self.hub, _id: id.to_string(), @@ -3068,7 +3064,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// /// * `id` - The ID of the table asset. /// * `filename` - The file name of this uploaded file. - pub fn files_insert(&self, id: &str, filename: &str) -> TableFileInsertCall<'a, C, NC, A> { + pub fn files_insert(&self, id: &str, filename: &str) -> TableFileInsertCall<'a, C, A> { TableFileInsertCall { hub: self.hub, _id: id.to_string(), @@ -3095,7 +3091,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the table to append the features to. - pub fn features_batch_insert(&self, request: &FeaturesBatchInsertRequest, id: &str) -> TableFeatureBatchInsertCall<'a, C, NC, A> { + pub fn features_batch_insert(&self, request: &FeaturesBatchInsertRequest, id: &str) -> TableFeatureBatchInsertCall<'a, C, A> { TableFeatureBatchInsertCall { hub: self.hub, _request: request.clone(), @@ -3109,7 +3105,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Return all tables readable by the current user. - pub fn list(&self) -> TableListCall<'a, C, NC, A> { + pub fn list(&self) -> TableListCall<'a, C, A> { TableListCall { hub: self.hub, _tags: Default::default(), @@ -3138,7 +3134,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the table. - pub fn get(&self, id: &str) -> TableGetCall<'a, C, NC, A> { + pub fn get(&self, id: &str) -> TableGetCall<'a, C, A> { TableGetCall { hub: self.hub, _id: id.to_string(), @@ -3157,7 +3153,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the table that contains the features to be deleted. - pub fn features_batch_delete(&self, request: &FeaturesBatchDeleteRequest, id: &str) -> TableFeatureBatchDeleteCall<'a, C, NC, A> { + pub fn features_batch_delete(&self, request: &FeaturesBatchDeleteRequest, id: &str) -> TableFeatureBatchDeleteCall<'a, C, A> { TableFeatureBatchDeleteCall { hub: self.hub, _request: request.clone(), @@ -3175,7 +3171,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the table to which these features belong. - pub fn features_list(&self, id: &str) -> TableFeatureListCall<'a, C, NC, A> { + pub fn features_list(&self, id: &str) -> TableFeatureListCall<'a, C, A> { TableFeatureListCall { hub: self.hub, _id: id.to_string(), @@ -3201,7 +3197,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the table. - pub fn process(&self, id: &str) -> TableProcesCall<'a, C, NC, A> { + pub fn process(&self, id: &str) -> TableProcesCall<'a, C, A> { TableProcesCall { hub: self.hub, _id: id.to_string(), @@ -3218,7 +3214,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the table whose parents will be listed. - pub fn parents_list(&self, id: &str) -> TableParentListCall<'a, C, NC, A> { + pub fn parents_list(&self, id: &str) -> TableParentListCall<'a, C, A> { TableParentListCall { hub: self.hub, _id: id.to_string(), @@ -3240,7 +3236,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the asset to which permissions will be added. - pub fn permissions_batch_update(&self, request: &PermissionsBatchUpdateRequest, id: &str) -> TablePermissionBatchUpdateCall<'a, C, NC, A> { + pub fn permissions_batch_update(&self, request: &PermissionsBatchUpdateRequest, id: &str) -> TablePermissionBatchUpdateCall<'a, C, A> { TablePermissionBatchUpdateCall { hub: self.hub, _request: request.clone(), @@ -3260,7 +3256,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn upload(&self, request: &Table) -> TableUploadCall<'a, C, NC, A> { + pub fn upload(&self, request: &Table) -> TableUploadCall<'a, C, A> { TableUploadCall { hub: self.hub, _request: request.clone(), @@ -3292,7 +3288,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the table containing the features to be patched. - pub fn features_batch_patch(&self, request: &FeaturesBatchPatchRequest, id: &str) -> TableFeatureBatchPatchCall<'a, C, NC, A> { + pub fn features_batch_patch(&self, request: &FeaturesBatchPatchRequest, id: &str) -> TableFeatureBatchPatchCall<'a, C, A> { TableFeatureBatchPatchCall { hub: self.hub, _request: request.clone(), @@ -3311,7 +3307,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the table. - pub fn patch(&self, request: &Table, id: &str) -> TablePatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Table, id: &str) -> TablePatchCall<'a, C, A> { TablePatchCall { hub: self.hub, _request: request.clone(), @@ -3330,7 +3326,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the asset from which permissions will be removed. - pub fn permissions_batch_delete(&self, request: &PermissionsBatchDeleteRequest, id: &str) -> TablePermissionBatchDeleteCall<'a, C, NC, A> { + pub fn permissions_batch_delete(&self, request: &PermissionsBatchDeleteRequest, id: &str) -> TablePermissionBatchDeleteCall<'a, C, A> { TablePermissionBatchDeleteCall { hub: self.hub, _request: request.clone(), @@ -3348,7 +3344,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn create(&self, request: &Table) -> TableCreateCall<'a, C, NC, A> { + pub fn create(&self, request: &Table) -> TableCreateCall<'a, C, A> { TableCreateCall { hub: self.hub, _request: request.clone(), @@ -3365,7 +3361,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the asset whose permissions will be listed. - pub fn permissions_list(&self, id: &str) -> TablePermissionListCall<'a, C, NC, A> { + pub fn permissions_list(&self, id: &str) -> TablePermissionListCall<'a, C, A> { TablePermissionListCall { hub: self.hub, _id: id.to_string(), @@ -3383,7 +3379,7 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// /// * `tableId` - The ID of the table. /// * `id` - The ID of the feature to get. - pub fn features_get(&self, table_id: &str, id: &str) -> TableFeatureGetCall<'a, C, NC, A> { + pub fn features_get(&self, table_id: &str, id: &str) -> TableFeatureGetCall<'a, C, A> { TableFeatureGetCall { hub: self.hub, _table_id: table_id.to_string(), @@ -3427,20 +3423,20 @@ impl<'a, C, NC, A> TableMethods<'a, C, NC, A> { /// let rb = hub.maps(); /// # } /// ``` -pub struct MapMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MapMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, } -impl<'a, C, NC, A> MethodsBuilder for MapMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for MapMethods<'a, C, A> {} -impl<'a, C, NC, A> MapMethods<'a, C, NC, A> { +impl<'a, C, A> MapMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Return all maps readable by the current user. - pub fn list(&self) -> MapListCall<'a, C, NC, A> { + pub fn list(&self) -> MapListCall<'a, C, A> { MapListCall { hub: self.hub, _tags: Default::default(), @@ -3465,7 +3461,7 @@ impl<'a, C, NC, A> MapMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Return all published maps readable by the current user. - pub fn list_published(&self) -> MapListPublishedCall<'a, C, NC, A> { + pub fn list_published(&self) -> MapListPublishedCall<'a, C, A> { MapListPublishedCall { hub: self.hub, _project_id: Default::default(), @@ -3485,7 +3481,7 @@ impl<'a, C, NC, A> MapMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the map. - pub fn patch(&self, request: &Map, id: &str) -> MapPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Map, id: &str) -> MapPatchCall<'a, C, A> { MapPatchCall { hub: self.hub, _request: request.clone(), @@ -3506,7 +3502,7 @@ impl<'a, C, NC, A> MapMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the asset to which permissions will be added. - pub fn permissions_batch_update(&self, request: &PermissionsBatchUpdateRequest, id: &str) -> MapPermissionBatchUpdateCall<'a, C, NC, A> { + pub fn permissions_batch_update(&self, request: &PermissionsBatchUpdateRequest, id: &str) -> MapPermissionBatchUpdateCall<'a, C, A> { MapPermissionBatchUpdateCall { hub: self.hub, _request: request.clone(), @@ -3524,7 +3520,7 @@ impl<'a, C, NC, A> MapMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the map. Only the map creator or project owner are permitted to delete. If the map is published the request will fail. Unpublish the map prior to deleting. - pub fn delete(&self, id: &str) -> MapDeleteCall<'a, C, NC, A> { + pub fn delete(&self, id: &str) -> MapDeleteCall<'a, C, A> { MapDeleteCall { hub: self.hub, _id: id.to_string(), @@ -3541,7 +3537,7 @@ impl<'a, C, NC, A> MapMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the map. - pub fn unpublish(&self, id: &str) -> MapUnpublishCall<'a, C, NC, A> { + pub fn unpublish(&self, id: &str) -> MapUnpublishCall<'a, C, A> { MapUnpublishCall { hub: self.hub, _id: id.to_string(), @@ -3558,7 +3554,7 @@ impl<'a, C, NC, A> MapMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the map. - pub fn publish(&self, id: &str) -> MapPublishCall<'a, C, NC, A> { + pub fn publish(&self, id: &str) -> MapPublishCall<'a, C, A> { MapPublishCall { hub: self.hub, _id: id.to_string(), @@ -3576,7 +3572,7 @@ impl<'a, C, NC, A> MapMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the asset whose permissions will be listed. - pub fn permissions_list(&self, id: &str) -> MapPermissionListCall<'a, C, NC, A> { + pub fn permissions_list(&self, id: &str) -> MapPermissionListCall<'a, C, A> { MapPermissionListCall { hub: self.hub, _id: id.to_string(), @@ -3593,7 +3589,7 @@ impl<'a, C, NC, A> MapMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn create(&self, request: &Map) -> MapCreateCall<'a, C, NC, A> { + pub fn create(&self, request: &Map) -> MapCreateCall<'a, C, A> { MapCreateCall { hub: self.hub, _request: request.clone(), @@ -3610,7 +3606,7 @@ impl<'a, C, NC, A> MapMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the map. - pub fn get_published(&self, id: &str) -> MapGetPublishedCall<'a, C, NC, A> { + pub fn get_published(&self, id: &str) -> MapGetPublishedCall<'a, C, A> { MapGetPublishedCall { hub: self.hub, _id: id.to_string(), @@ -3627,7 +3623,7 @@ impl<'a, C, NC, A> MapMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the map. - pub fn get(&self, id: &str) -> MapGetCall<'a, C, NC, A> { + pub fn get(&self, id: &str) -> MapGetCall<'a, C, A> { MapGetCall { hub: self.hub, _id: id.to_string(), @@ -3646,7 +3642,7 @@ impl<'a, C, NC, A> MapMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the asset from which permissions will be removed. - pub fn permissions_batch_delete(&self, request: &PermissionsBatchDeleteRequest, id: &str) -> MapPermissionBatchDeleteCall<'a, C, NC, A> { + pub fn permissions_batch_delete(&self, request: &PermissionsBatchDeleteRequest, id: &str) -> MapPermissionBatchDeleteCall<'a, C, A> { MapPermissionBatchDeleteCall { hub: self.hub, _request: request.clone(), @@ -3688,15 +3684,15 @@ impl<'a, C, NC, A> MapMethods<'a, C, NC, A> { /// let rb = hub.raster_collections(); /// # } /// ``` -pub struct RasterCollectionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterCollectionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, } -impl<'a, C, NC, A> MethodsBuilder for RasterCollectionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for RasterCollectionMethods<'a, C, A> {} -impl<'a, C, NC, A> RasterCollectionMethods<'a, C, NC, A> { +impl<'a, C, A> RasterCollectionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -3705,7 +3701,7 @@ impl<'a, C, NC, A> RasterCollectionMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn create(&self, request: &RasterCollection) -> RasterCollectionCreateCall<'a, C, NC, A> { + pub fn create(&self, request: &RasterCollection) -> RasterCollectionCreateCall<'a, C, A> { RasterCollectionCreateCall { hub: self.hub, _request: request.clone(), @@ -3723,7 +3719,7 @@ impl<'a, C, NC, A> RasterCollectionMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the asset from which permissions will be removed. - pub fn permissions_batch_delete(&self, request: &PermissionsBatchDeleteRequest, id: &str) -> RasterCollectionPermissionBatchDeleteCall<'a, C, NC, A> { + pub fn permissions_batch_delete(&self, request: &PermissionsBatchDeleteRequest, id: &str) -> RasterCollectionPermissionBatchDeleteCall<'a, C, A> { RasterCollectionPermissionBatchDeleteCall { hub: self.hub, _request: request.clone(), @@ -3742,7 +3738,7 @@ impl<'a, C, NC, A> RasterCollectionMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the raster collection. - pub fn patch(&self, request: &RasterCollection, id: &str) -> RasterCollectionPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &RasterCollection, id: &str) -> RasterCollectionPatchCall<'a, C, A> { RasterCollectionPatchCall { hub: self.hub, _request: request.clone(), @@ -3760,7 +3756,7 @@ impl<'a, C, NC, A> RasterCollectionMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the raster collection. - pub fn cancel_processing(&self, id: &str) -> RasterCollectionCancelProcessingCall<'a, C, NC, A> { + pub fn cancel_processing(&self, id: &str) -> RasterCollectionCancelProcessingCall<'a, C, A> { RasterCollectionCancelProcessingCall { hub: self.hub, _id: id.to_string(), @@ -3777,7 +3773,7 @@ impl<'a, C, NC, A> RasterCollectionMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the raster collection. - pub fn process(&self, id: &str) -> RasterCollectionProcesCall<'a, C, NC, A> { + pub fn process(&self, id: &str) -> RasterCollectionProcesCall<'a, C, A> { RasterCollectionProcesCall { hub: self.hub, _id: id.to_string(), @@ -3797,7 +3793,7 @@ impl<'a, C, NC, A> RasterCollectionMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the asset to which permissions will be added. - pub fn permissions_batch_update(&self, request: &PermissionsBatchUpdateRequest, id: &str) -> RasterCollectionPermissionBatchUpdateCall<'a, C, NC, A> { + pub fn permissions_batch_update(&self, request: &PermissionsBatchUpdateRequest, id: &str) -> RasterCollectionPermissionBatchUpdateCall<'a, C, A> { RasterCollectionPermissionBatchUpdateCall { hub: self.hub, _request: request.clone(), @@ -3815,7 +3811,7 @@ impl<'a, C, NC, A> RasterCollectionMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the raster collection. Only the raster collection creator or project owner are permitted to delete. If the rastor collection is included in a layer, the request will fail. Remove the raster collection from all layers prior to deleting. - pub fn delete(&self, id: &str) -> RasterCollectionDeleteCall<'a, C, NC, A> { + pub fn delete(&self, id: &str) -> RasterCollectionDeleteCall<'a, C, A> { RasterCollectionDeleteCall { hub: self.hub, _id: id.to_string(), @@ -3832,7 +3828,7 @@ impl<'a, C, NC, A> RasterCollectionMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the raster collection whose parents will be listed. - pub fn parents_list(&self, id: &str) -> RasterCollectionParentListCall<'a, C, NC, A> { + pub fn parents_list(&self, id: &str) -> RasterCollectionParentListCall<'a, C, A> { RasterCollectionParentListCall { hub: self.hub, _id: id.to_string(), @@ -3847,7 +3843,7 @@ impl<'a, C, NC, A> RasterCollectionMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Return all raster collections readable by the current user. - pub fn list(&self) -> RasterCollectionListCall<'a, C, NC, A> { + pub fn list(&self) -> RasterCollectionListCall<'a, C, A> { RasterCollectionListCall { hub: self.hub, _tags: Default::default(), @@ -3879,7 +3875,7 @@ impl<'a, C, NC, A> RasterCollectionMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the raster collection to which these rasters belong. - pub fn rasters_batch_insert(&self, request: &RasterCollectionsRastersBatchInsertRequest, id: &str) -> RasterCollectionRasterBatchInsertCall<'a, C, NC, A> { + pub fn rasters_batch_insert(&self, request: &RasterCollectionsRastersBatchInsertRequest, id: &str) -> RasterCollectionRasterBatchInsertCall<'a, C, A> { RasterCollectionRasterBatchInsertCall { hub: self.hub, _request: request.clone(), @@ -3900,7 +3896,7 @@ impl<'a, C, NC, A> RasterCollectionMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the raster collection to which these rasters belong. - pub fn rasters_batch_delete(&self, request: &RasterCollectionsRasterBatchDeleteRequest, id: &str) -> RasterCollectionRasterBatchDeleteCall<'a, C, NC, A> { + pub fn rasters_batch_delete(&self, request: &RasterCollectionsRasterBatchDeleteRequest, id: &str) -> RasterCollectionRasterBatchDeleteCall<'a, C, A> { RasterCollectionRasterBatchDeleteCall { hub: self.hub, _request: request.clone(), @@ -3918,7 +3914,7 @@ impl<'a, C, NC, A> RasterCollectionMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the asset whose permissions will be listed. - pub fn permissions_list(&self, id: &str) -> RasterCollectionPermissionListCall<'a, C, NC, A> { + pub fn permissions_list(&self, id: &str) -> RasterCollectionPermissionListCall<'a, C, A> { RasterCollectionPermissionListCall { hub: self.hub, _id: id.to_string(), @@ -3935,7 +3931,7 @@ impl<'a, C, NC, A> RasterCollectionMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the raster collection. - pub fn get(&self, id: &str) -> RasterCollectionGetCall<'a, C, NC, A> { + pub fn get(&self, id: &str) -> RasterCollectionGetCall<'a, C, A> { RasterCollectionGetCall { hub: self.hub, _id: id.to_string(), @@ -3952,7 +3948,7 @@ impl<'a, C, NC, A> RasterCollectionMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the raster collection to which these rasters belong. - pub fn rasters_list(&self, id: &str) -> RasterCollectionRasterListCall<'a, C, NC, A> { + pub fn rasters_list(&self, id: &str) -> RasterCollectionRasterListCall<'a, C, A> { RasterCollectionRasterListCall { hub: self.hub, _id: id.to_string(), @@ -4004,15 +4000,15 @@ impl<'a, C, NC, A> RasterCollectionMethods<'a, C, NC, A> { /// let rb = hub.projects(); /// # } /// ``` -pub struct ProjectMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, } -impl<'a, C, NC, A> MethodsBuilder for ProjectMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ProjectMethods<'a, C, A> {} -impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { +impl<'a, C, A> ProjectMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -4022,7 +4018,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// /// * `projectId` - The ID of the project. /// * `id` - The ID of the icon. - pub fn icons_get(&self, project_id: &str, id: &str) -> ProjectIconGetCall<'a, C, NC, A> { + pub fn icons_get(&self, project_id: &str, id: &str) -> ProjectIconGetCall<'a, C, A> { ProjectIconGetCall { hub: self.hub, _project_id: project_id.to_string(), @@ -4041,7 +4037,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `projectId` - The ID of the project. - pub fn icons_create(&self, request: &Icon, project_id: &str) -> ProjectIconCreateCall<'a, C, NC, A> { + pub fn icons_create(&self, request: &Icon, project_id: &str) -> ProjectIconCreateCall<'a, C, A> { ProjectIconCreateCall { hub: self.hub, _request: request.clone(), @@ -4055,7 +4051,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Return all projects readable by the current user. - pub fn list(&self) -> ProjectListCall<'a, C, NC, A> { + pub fn list(&self) -> ProjectListCall<'a, C, A> { ProjectListCall { hub: self.hub, _delegate: Default::default(), @@ -4071,7 +4067,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// # Arguments /// /// * `projectId` - The ID of the project. - pub fn icons_list(&self, project_id: &str) -> ProjectIconListCall<'a, C, NC, A> { + pub fn icons_list(&self, project_id: &str) -> ProjectIconListCall<'a, C, A> { ProjectIconListCall { hub: self.hub, _project_id: project_id.to_string(), @@ -4122,19 +4118,19 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct LayerUnpublishCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LayerUnpublishCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LayerUnpublishCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LayerUnpublishCall<'a, C, A> {} -impl<'a, C, NC, A> LayerUnpublishCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LayerUnpublishCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4266,7 +4262,7 @@ impl<'a, C, NC, A> LayerUnpublishCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the layer. - pub fn id(mut self, new_value: &str) -> LayerUnpublishCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> LayerUnpublishCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -4277,7 +4273,7 @@ impl<'a, C, NC, A> LayerUnpublishCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerUnpublishCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerUnpublishCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4298,7 +4294,7 @@ impl<'a, C, NC, A> LayerUnpublishCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LayerUnpublishCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LayerUnpublishCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4315,7 +4311,7 @@ impl<'a, C, NC, A> LayerUnpublishCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LayerUnpublishCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LayerUnpublishCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4354,10 +4350,10 @@ impl<'a, C, NC, A> LayerUnpublishCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct LayerPublishCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LayerPublishCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _force: Option, _delegate: Option<&'a mut Delegate>, @@ -4365,9 +4361,9 @@ pub struct LayerPublishCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LayerPublishCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LayerPublishCall<'a, C, A> {} -impl<'a, C, NC, A> LayerPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LayerPublishCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4502,7 +4498,7 @@ impl<'a, C, NC, A> LayerPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the layer. - pub fn id(mut self, new_value: &str) -> LayerPublishCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> LayerPublishCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -4510,7 +4506,7 @@ impl<'a, C, NC, A> LayerPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// If set to true, the API will allow publication of the layer even if it's out of date. If not true, you'll need to reprocess any out-of-date layer before publishing. - pub fn force(mut self, new_value: bool) -> LayerPublishCall<'a, C, NC, A> { + pub fn force(mut self, new_value: bool) -> LayerPublishCall<'a, C, A> { self._force = Some(new_value); self } @@ -4521,7 +4517,7 @@ impl<'a, C, NC, A> LayerPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerPublishCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerPublishCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4542,7 +4538,7 @@ impl<'a, C, NC, A> LayerPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LayerPublishCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LayerPublishCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4559,7 +4555,7 @@ impl<'a, C, NC, A> LayerPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LayerPublishCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LayerPublishCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4600,10 +4596,10 @@ impl<'a, C, NC, A> LayerPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct LayerListPublishedCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LayerListPublishedCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _project_id: Option, _page_token: Option, _max_results: Option, @@ -4612,9 +4608,9 @@ pub struct LayerListPublishedCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LayerListPublishedCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LayerListPublishedCall<'a, C, A> {} -impl<'a, C, NC, A> LayerListPublishedCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LayerListPublishedCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4728,7 +4724,7 @@ impl<'a, C, NC, A> LayerListPublishedCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// The ID of a Maps Engine project, used to filter the response. To list all available projects with their IDs, send a Projects: list request. You can also find your project ID as the value of the DashboardPlace:cid URL parameter when signed in to mapsengine.google.com. - pub fn project_id(mut self, new_value: &str) -> LayerListPublishedCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> LayerListPublishedCall<'a, C, A> { self._project_id = Some(new_value.to_string()); self } @@ -4736,7 +4732,7 @@ impl<'a, C, NC, A> LayerListPublishedCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// The continuation token, used to page through large result sets. To get the next page of results, set this parameter to the value of nextPageToken from the previous response. - pub fn page_token(mut self, new_value: &str) -> LayerListPublishedCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> LayerListPublishedCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -4744,7 +4740,7 @@ impl<'a, C, NC, A> LayerListPublishedCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// The maximum number of items to include in a single response page. The maximum supported value is 100. - pub fn max_results(mut self, new_value: u32) -> LayerListPublishedCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> LayerListPublishedCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -4755,7 +4751,7 @@ impl<'a, C, NC, A> LayerListPublishedCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerListPublishedCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerListPublishedCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4776,7 +4772,7 @@ impl<'a, C, NC, A> LayerListPublishedCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LayerListPublishedCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LayerListPublishedCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4793,7 +4789,7 @@ impl<'a, C, NC, A> LayerListPublishedCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LayerListPublishedCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LayerListPublishedCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4838,10 +4834,10 @@ impl<'a, C, NC, A> LayerListPublishedCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct LayerCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LayerCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: Layer, _process: Option, _delegate: Option<&'a mut Delegate>, @@ -4849,9 +4845,9 @@ pub struct LayerCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LayerCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LayerCreateCall<'a, C, A> {} -impl<'a, C, NC, A> LayerCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LayerCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4968,7 +4964,7 @@ impl<'a, C, NC, A> LayerCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Layer) -> LayerCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Layer) -> LayerCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4976,7 +4972,7 @@ impl<'a, C, NC, A> LayerCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Whether to queue the created layer for processing. - pub fn process(mut self, new_value: bool) -> LayerCreateCall<'a, C, NC, A> { + pub fn process(mut self, new_value: bool) -> LayerCreateCall<'a, C, A> { self._process = Some(new_value); self } @@ -4987,7 +4983,7 @@ impl<'a, C, NC, A> LayerCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5008,7 +5004,7 @@ impl<'a, C, NC, A> LayerCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LayerCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LayerCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5025,7 +5021,7 @@ impl<'a, C, NC, A> LayerCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LayerCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LayerCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5063,19 +5059,19 @@ impl<'a, C, NC, A> LayerCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct LayerGetPublishedCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LayerGetPublishedCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LayerGetPublishedCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LayerGetPublishedCall<'a, C, A> {} -impl<'a, C, NC, A> LayerGetPublishedCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LayerGetPublishedCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5207,7 +5203,7 @@ impl<'a, C, NC, A> LayerGetPublishedCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the layer. - pub fn id(mut self, new_value: &str) -> LayerGetPublishedCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> LayerGetPublishedCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -5218,7 +5214,7 @@ impl<'a, C, NC, A> LayerGetPublishedCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerGetPublishedCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerGetPublishedCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5239,7 +5235,7 @@ impl<'a, C, NC, A> LayerGetPublishedCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LayerGetPublishedCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LayerGetPublishedCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5256,7 +5252,7 @@ impl<'a, C, NC, A> LayerGetPublishedCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LayerGetPublishedCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LayerGetPublishedCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5294,19 +5290,19 @@ impl<'a, C, NC, A> LayerGetPublishedCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct LayerDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LayerDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LayerDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LayerDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> LayerDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LayerDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5427,7 +5423,7 @@ impl<'a, C, NC, A> LayerDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the layer. Only the layer creator or project owner are permitted to delete. If the layer is published, or included in a map, the request will fail. Unpublish the layer, and remove it from all maps prior to deleting. - pub fn id(mut self, new_value: &str) -> LayerDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> LayerDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -5438,7 +5434,7 @@ impl<'a, C, NC, A> LayerDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5459,7 +5455,7 @@ impl<'a, C, NC, A> LayerDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LayerDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LayerDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5476,7 +5472,7 @@ impl<'a, C, NC, A> LayerDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LayerDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LayerDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5515,10 +5511,10 @@ impl<'a, C, NC, A> LayerDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct LayerGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LayerGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _version: Option, _delegate: Option<&'a mut Delegate>, @@ -5526,9 +5522,9 @@ pub struct LayerGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LayerGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LayerGetCall<'a, C, A> {} -impl<'a, C, NC, A> LayerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LayerGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5663,7 +5659,7 @@ impl<'a, C, NC, A> LayerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The ID of the layer. - pub fn id(mut self, new_value: &str) -> LayerGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> LayerGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -5671,7 +5667,7 @@ impl<'a, C, NC, A> LayerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Deprecated: The version parameter indicates which version of the layer should be returned. When version is set to published, the published version of the layer will be returned. Please use the layers.getPublished endpoint instead. - pub fn version(mut self, new_value: &str) -> LayerGetCall<'a, C, NC, A> { + pub fn version(mut self, new_value: &str) -> LayerGetCall<'a, C, A> { self._version = Some(new_value.to_string()); self } @@ -5682,7 +5678,7 @@ impl<'a, C, NC, A> LayerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5703,7 +5699,7 @@ impl<'a, C, NC, A> LayerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LayerGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LayerGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5720,7 +5716,7 @@ impl<'a, C, NC, A> LayerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LayerGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LayerGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5764,10 +5760,10 @@ impl<'a, C, NC, A> LayerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct LayerPermissionBatchDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LayerPermissionBatchDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: PermissionsBatchDeleteRequest, _id: String, _delegate: Option<&'a mut Delegate>, @@ -5775,9 +5771,9 @@ pub struct LayerPermissionBatchDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LayerPermissionBatchDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LayerPermissionBatchDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> LayerPermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LayerPermissionBatchDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5916,7 +5912,7 @@ impl<'a, C, NC, A> LayerPermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PermissionsBatchDeleteRequest) -> LayerPermissionBatchDeleteCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PermissionsBatchDeleteRequest) -> LayerPermissionBatchDeleteCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5926,7 +5922,7 @@ impl<'a, C, NC, A> LayerPermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The ID of the asset from which permissions will be removed. - pub fn id(mut self, new_value: &str) -> LayerPermissionBatchDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> LayerPermissionBatchDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -5937,7 +5933,7 @@ impl<'a, C, NC, A> LayerPermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerPermissionBatchDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerPermissionBatchDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5958,7 +5954,7 @@ impl<'a, C, NC, A> LayerPermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LayerPermissionBatchDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LayerPermissionBatchDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5975,7 +5971,7 @@ impl<'a, C, NC, A> LayerPermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LayerPermissionBatchDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LayerPermissionBatchDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6021,10 +6017,10 @@ impl<'a, C, NC, A> LayerPermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct LayerPermissionBatchUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LayerPermissionBatchUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: PermissionsBatchUpdateRequest, _id: String, _delegate: Option<&'a mut Delegate>, @@ -6032,9 +6028,9 @@ pub struct LayerPermissionBatchUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LayerPermissionBatchUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LayerPermissionBatchUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> LayerPermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LayerPermissionBatchUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6173,7 +6169,7 @@ impl<'a, C, NC, A> LayerPermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PermissionsBatchUpdateRequest) -> LayerPermissionBatchUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PermissionsBatchUpdateRequest) -> LayerPermissionBatchUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6183,7 +6179,7 @@ impl<'a, C, NC, A> LayerPermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The ID of the asset to which permissions will be added. - pub fn id(mut self, new_value: &str) -> LayerPermissionBatchUpdateCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> LayerPermissionBatchUpdateCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -6194,7 +6190,7 @@ impl<'a, C, NC, A> LayerPermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerPermissionBatchUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerPermissionBatchUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6215,7 +6211,7 @@ impl<'a, C, NC, A> LayerPermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LayerPermissionBatchUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LayerPermissionBatchUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6232,7 +6228,7 @@ impl<'a, C, NC, A> LayerPermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LayerPermissionBatchUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LayerPermissionBatchUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6283,10 +6279,10 @@ impl<'a, C, NC, A> LayerPermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct LayerListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LayerListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _tags: Option, _search: Option, _role: Option, @@ -6305,9 +6301,9 @@ pub struct LayerListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LayerListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LayerListCall<'a, C, A> {} -impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LayerListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6451,7 +6447,7 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// A comma separated list of tags. Returned assets will contain all the tags from the list. - pub fn tags(mut self, new_value: &str) -> LayerListCall<'a, C, NC, A> { + pub fn tags(mut self, new_value: &str) -> LayerListCall<'a, C, A> { self._tags = Some(new_value.to_string()); self } @@ -6459,7 +6455,7 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// An unstructured search string used to filter the set of results based on asset metadata. - pub fn search(mut self, new_value: &str) -> LayerListCall<'a, C, NC, A> { + pub fn search(mut self, new_value: &str) -> LayerListCall<'a, C, A> { self._search = Some(new_value.to_string()); self } @@ -6467,7 +6463,7 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The role parameter indicates that the response should only contain assets where the current user has the specified level of access. - pub fn role(mut self, new_value: &str) -> LayerListCall<'a, C, NC, A> { + pub fn role(mut self, new_value: &str) -> LayerListCall<'a, C, A> { self._role = Some(new_value.to_string()); self } @@ -6475,14 +6471,14 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The ID of a Maps Engine project, used to filter the response. To list all available projects with their IDs, send a Projects: list request. You can also find your project ID as the value of the DashboardPlace:cid URL parameter when signed in to mapsengine.google.com. - pub fn project_id(mut self, new_value: &str) -> LayerListCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> LayerListCall<'a, C, A> { self._project_id = Some(new_value.to_string()); self } /// Sets the *processing status* query property to the given value. /// /// - pub fn processing_status(mut self, new_value: &str) -> LayerListCall<'a, C, NC, A> { + pub fn processing_status(mut self, new_value: &str) -> LayerListCall<'a, C, A> { self._processing_status = Some(new_value.to_string()); self } @@ -6490,7 +6486,7 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The continuation token, used to page through large result sets. To get the next page of results, set this parameter to the value of nextPageToken from the previous response. - pub fn page_token(mut self, new_value: &str) -> LayerListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> LayerListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -6498,7 +6494,7 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been modified at or before this time. - pub fn modified_before(mut self, new_value: &str) -> LayerListCall<'a, C, NC, A> { + pub fn modified_before(mut self, new_value: &str) -> LayerListCall<'a, C, A> { self._modified_before = Some(new_value.to_string()); self } @@ -6506,7 +6502,7 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been modified at or after this time. - pub fn modified_after(mut self, new_value: &str) -> LayerListCall<'a, C, NC, A> { + pub fn modified_after(mut self, new_value: &str) -> LayerListCall<'a, C, A> { self._modified_after = Some(new_value.to_string()); self } @@ -6514,7 +6510,7 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The maximum number of items to include in a single response page. The maximum supported value is 100. - pub fn max_results(mut self, new_value: u32) -> LayerListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> LayerListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -6522,7 +6518,7 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// An email address representing a user. Returned assets that have been created by the user associated with the provided email address. - pub fn creator_email(mut self, new_value: &str) -> LayerListCall<'a, C, NC, A> { + pub fn creator_email(mut self, new_value: &str) -> LayerListCall<'a, C, A> { self._creator_email = Some(new_value.to_string()); self } @@ -6530,7 +6526,7 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been created at or before this time. - pub fn created_before(mut self, new_value: &str) -> LayerListCall<'a, C, NC, A> { + pub fn created_before(mut self, new_value: &str) -> LayerListCall<'a, C, A> { self._created_before = Some(new_value.to_string()); self } @@ -6538,7 +6534,7 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been created at or after this time. - pub fn created_after(mut self, new_value: &str) -> LayerListCall<'a, C, NC, A> { + pub fn created_after(mut self, new_value: &str) -> LayerListCall<'a, C, A> { self._created_after = Some(new_value.to_string()); self } @@ -6546,7 +6542,7 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// A bounding box, expressed as "west,south,east,north". If set, only assets which intersect this bounding box will be returned. - pub fn bbox(mut self, new_value: &str) -> LayerListCall<'a, C, NC, A> { + pub fn bbox(mut self, new_value: &str) -> LayerListCall<'a, C, A> { self._bbox = Some(new_value.to_string()); self } @@ -6557,7 +6553,7 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6578,7 +6574,7 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LayerListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LayerListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6595,7 +6591,7 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LayerListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LayerListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6635,10 +6631,10 @@ impl<'a, C, NC, A> LayerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct LayerParentListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LayerParentListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _page_token: Option, _max_results: Option, @@ -6647,9 +6643,9 @@ pub struct LayerParentListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LayerParentListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LayerParentListCall<'a, C, A> {} -impl<'a, C, NC, A> LayerParentListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LayerParentListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6787,7 +6783,7 @@ impl<'a, C, NC, A> LayerParentListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the layer whose parents will be listed. - pub fn id(mut self, new_value: &str) -> LayerParentListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> LayerParentListCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -6795,7 +6791,7 @@ impl<'a, C, NC, A> LayerParentListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The continuation token, used to page through large result sets. To get the next page of results, set this parameter to the value of nextPageToken from the previous response. - pub fn page_token(mut self, new_value: &str) -> LayerParentListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> LayerParentListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -6803,7 +6799,7 @@ impl<'a, C, NC, A> LayerParentListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The maximum number of items to include in a single response page. The maximum supported value is 50. - pub fn max_results(mut self, new_value: u32) -> LayerParentListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> LayerParentListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -6814,7 +6810,7 @@ impl<'a, C, NC, A> LayerParentListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerParentListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerParentListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6835,7 +6831,7 @@ impl<'a, C, NC, A> LayerParentListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LayerParentListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LayerParentListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6852,7 +6848,7 @@ impl<'a, C, NC, A> LayerParentListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LayerParentListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LayerParentListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6890,19 +6886,19 @@ impl<'a, C, NC, A> LayerParentListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct LayerCancelProcessingCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LayerCancelProcessingCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LayerCancelProcessingCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LayerCancelProcessingCall<'a, C, A> {} -impl<'a, C, NC, A> LayerCancelProcessingCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LayerCancelProcessingCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7034,7 +7030,7 @@ impl<'a, C, NC, A> LayerCancelProcessingCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The ID of the layer. - pub fn id(mut self, new_value: &str) -> LayerCancelProcessingCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> LayerCancelProcessingCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -7045,7 +7041,7 @@ impl<'a, C, NC, A> LayerCancelProcessingCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerCancelProcessingCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerCancelProcessingCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7066,7 +7062,7 @@ impl<'a, C, NC, A> LayerCancelProcessingCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LayerCancelProcessingCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LayerCancelProcessingCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7083,7 +7079,7 @@ impl<'a, C, NC, A> LayerCancelProcessingCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LayerCancelProcessingCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LayerCancelProcessingCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7127,10 +7123,10 @@ impl<'a, C, NC, A> LayerCancelProcessingCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct LayerPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LayerPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: Layer, _id: String, _delegate: Option<&'a mut Delegate>, @@ -7138,9 +7134,9 @@ pub struct LayerPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LayerPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LayerPatchCall<'a, C, A> {} -impl<'a, C, NC, A> LayerPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LayerPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7268,7 +7264,7 @@ impl<'a, C, NC, A> LayerPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Layer) -> LayerPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Layer) -> LayerPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7278,7 +7274,7 @@ impl<'a, C, NC, A> LayerPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the layer. - pub fn id(mut self, new_value: &str) -> LayerPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> LayerPatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -7289,7 +7285,7 @@ impl<'a, C, NC, A> LayerPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7310,7 +7306,7 @@ impl<'a, C, NC, A> LayerPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LayerPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LayerPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7327,7 +7323,7 @@ impl<'a, C, NC, A> LayerPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LayerPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LayerPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7365,19 +7361,19 @@ impl<'a, C, NC, A> LayerPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct LayerPermissionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LayerPermissionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LayerPermissionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LayerPermissionListCall<'a, C, A> {} -impl<'a, C, NC, A> LayerPermissionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LayerPermissionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7509,7 +7505,7 @@ impl<'a, C, NC, A> LayerPermissionListCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The ID of the asset whose permissions will be listed. - pub fn id(mut self, new_value: &str) -> LayerPermissionListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> LayerPermissionListCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -7520,7 +7516,7 @@ impl<'a, C, NC, A> LayerPermissionListCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerPermissionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerPermissionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7541,7 +7537,7 @@ impl<'a, C, NC, A> LayerPermissionListCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LayerPermissionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LayerPermissionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7558,7 +7554,7 @@ impl<'a, C, NC, A> LayerPermissionListCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LayerPermissionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LayerPermissionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7596,19 +7592,19 @@ impl<'a, C, NC, A> LayerPermissionListCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct LayerProcesCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LayerProcesCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LayerProcesCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LayerProcesCall<'a, C, A> {} -impl<'a, C, NC, A> LayerProcesCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LayerProcesCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7740,7 +7736,7 @@ impl<'a, C, NC, A> LayerProcesCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the layer. - pub fn id(mut self, new_value: &str) -> LayerProcesCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> LayerProcesCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -7751,7 +7747,7 @@ impl<'a, C, NC, A> LayerProcesCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerProcesCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LayerProcesCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7772,7 +7768,7 @@ impl<'a, C, NC, A> LayerProcesCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LayerProcesCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LayerProcesCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7789,7 +7785,7 @@ impl<'a, C, NC, A> LayerProcesCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LayerProcesCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LayerProcesCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7835,10 +7831,10 @@ impl<'a, C, NC, A> LayerProcesCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct RasterPermissionBatchUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterPermissionBatchUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: PermissionsBatchUpdateRequest, _id: String, _delegate: Option<&'a mut Delegate>, @@ -7846,9 +7842,9 @@ pub struct RasterPermissionBatchUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterPermissionBatchUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterPermissionBatchUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> RasterPermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterPermissionBatchUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7987,7 +7983,7 @@ impl<'a, C, NC, A> RasterPermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PermissionsBatchUpdateRequest) -> RasterPermissionBatchUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PermissionsBatchUpdateRequest) -> RasterPermissionBatchUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7997,7 +7993,7 @@ impl<'a, C, NC, A> RasterPermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The ID of the asset to which permissions will be added. - pub fn id(mut self, new_value: &str) -> RasterPermissionBatchUpdateCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> RasterPermissionBatchUpdateCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -8008,7 +8004,7 @@ impl<'a, C, NC, A> RasterPermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterPermissionBatchUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterPermissionBatchUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8029,7 +8025,7 @@ impl<'a, C, NC, A> RasterPermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterPermissionBatchUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterPermissionBatchUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8046,7 +8042,7 @@ impl<'a, C, NC, A> RasterPermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterPermissionBatchUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterPermissionBatchUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8090,10 +8086,10 @@ impl<'a, C, NC, A> RasterPermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct RasterPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: Raster, _id: String, _delegate: Option<&'a mut Delegate>, @@ -8101,9 +8097,9 @@ pub struct RasterPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterPatchCall<'a, C, A> {} -impl<'a, C, NC, A> RasterPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8231,7 +8227,7 @@ impl<'a, C, NC, A> RasterPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Raster) -> RasterPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Raster) -> RasterPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8241,7 +8237,7 @@ impl<'a, C, NC, A> RasterPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the raster. - pub fn id(mut self, new_value: &str) -> RasterPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> RasterPatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -8252,7 +8248,7 @@ impl<'a, C, NC, A> RasterPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8273,7 +8269,7 @@ impl<'a, C, NC, A> RasterPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8290,7 +8286,7 @@ impl<'a, C, NC, A> RasterPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8328,19 +8324,19 @@ impl<'a, C, NC, A> RasterPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct RasterPermissionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterPermissionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterPermissionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterPermissionListCall<'a, C, A> {} -impl<'a, C, NC, A> RasterPermissionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterPermissionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8472,7 +8468,7 @@ impl<'a, C, NC, A> RasterPermissionListCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The ID of the asset whose permissions will be listed. - pub fn id(mut self, new_value: &str) -> RasterPermissionListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> RasterPermissionListCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -8483,7 +8479,7 @@ impl<'a, C, NC, A> RasterPermissionListCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterPermissionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterPermissionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8504,7 +8500,7 @@ impl<'a, C, NC, A> RasterPermissionListCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterPermissionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterPermissionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8521,7 +8517,7 @@ impl<'a, C, NC, A> RasterPermissionListCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterPermissionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterPermissionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8559,19 +8555,19 @@ impl<'a, C, NC, A> RasterPermissionListCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct RasterDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> RasterDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8692,7 +8688,7 @@ impl<'a, C, NC, A> RasterDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the raster. Only the raster creator or project owner are permitted to delete. If the raster is included in a layer or mosaic, the request will fail. Remove it from all parents prior to deleting. - pub fn id(mut self, new_value: &str) -> RasterDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> RasterDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -8703,7 +8699,7 @@ impl<'a, C, NC, A> RasterDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8724,7 +8720,7 @@ impl<'a, C, NC, A> RasterDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8741,7 +8737,7 @@ impl<'a, C, NC, A> RasterDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8785,10 +8781,10 @@ impl<'a, C, NC, A> RasterDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct RasterPermissionBatchDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterPermissionBatchDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: PermissionsBatchDeleteRequest, _id: String, _delegate: Option<&'a mut Delegate>, @@ -8796,9 +8792,9 @@ pub struct RasterPermissionBatchDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterPermissionBatchDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterPermissionBatchDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> RasterPermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterPermissionBatchDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8937,7 +8933,7 @@ impl<'a, C, NC, A> RasterPermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PermissionsBatchDeleteRequest) -> RasterPermissionBatchDeleteCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PermissionsBatchDeleteRequest) -> RasterPermissionBatchDeleteCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8947,7 +8943,7 @@ impl<'a, C, NC, A> RasterPermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The ID of the asset from which permissions will be removed. - pub fn id(mut self, new_value: &str) -> RasterPermissionBatchDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> RasterPermissionBatchDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -8958,7 +8954,7 @@ impl<'a, C, NC, A> RasterPermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterPermissionBatchDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterPermissionBatchDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8979,7 +8975,7 @@ impl<'a, C, NC, A> RasterPermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterPermissionBatchDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterPermissionBatchDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8996,7 +8992,7 @@ impl<'a, C, NC, A> RasterPermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterPermissionBatchDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterPermissionBatchDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9035,10 +9031,10 @@ impl<'a, C, NC, A> RasterPermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper /// .upload_resumable(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct RasterFileInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterFileInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _filename: String, _delegate: Option<&'a mut Delegate>, @@ -9046,9 +9042,9 @@ pub struct RasterFileInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterFileInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterFileInsertCall<'a, C, A> {} -impl<'a, C, NC, A> RasterFileInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterFileInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9279,7 +9275,7 @@ impl<'a, C, NC, A> RasterFileInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID of the raster asset. - pub fn id(mut self, new_value: &str) -> RasterFileInsertCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> RasterFileInsertCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -9289,7 +9285,7 @@ impl<'a, C, NC, A> RasterFileInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The file name of this uploaded file. - pub fn filename(mut self, new_value: &str) -> RasterFileInsertCall<'a, C, NC, A> { + pub fn filename(mut self, new_value: &str) -> RasterFileInsertCall<'a, C, A> { self._filename = new_value.to_string(); self } @@ -9300,7 +9296,7 @@ impl<'a, C, NC, A> RasterFileInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterFileInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterFileInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9321,7 +9317,7 @@ impl<'a, C, NC, A> RasterFileInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterFileInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterFileInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9338,7 +9334,7 @@ impl<'a, C, NC, A> RasterFileInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterFileInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterFileInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9376,19 +9372,19 @@ impl<'a, C, NC, A> RasterFileInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct RasterProcesCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterProcesCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterProcesCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterProcesCall<'a, C, A> {} -impl<'a, C, NC, A> RasterProcesCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterProcesCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9520,7 +9516,7 @@ impl<'a, C, NC, A> RasterProcesCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the raster. - pub fn id(mut self, new_value: &str) -> RasterProcesCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> RasterProcesCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -9531,7 +9527,7 @@ impl<'a, C, NC, A> RasterProcesCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterProcesCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterProcesCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9552,7 +9548,7 @@ impl<'a, C, NC, A> RasterProcesCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterProcesCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterProcesCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9569,7 +9565,7 @@ impl<'a, C, NC, A> RasterProcesCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterProcesCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterProcesCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9607,19 +9603,19 @@ impl<'a, C, NC, A> RasterProcesCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct RasterGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterGetCall<'a, C, A> {} -impl<'a, C, NC, A> RasterGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9751,7 +9747,7 @@ impl<'a, C, NC, A> RasterGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the raster. - pub fn id(mut self, new_value: &str) -> RasterGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> RasterGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -9762,7 +9758,7 @@ impl<'a, C, NC, A> RasterGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9783,7 +9779,7 @@ impl<'a, C, NC, A> RasterGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9800,7 +9796,7 @@ impl<'a, C, NC, A> RasterGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9850,10 +9846,10 @@ impl<'a, C, NC, A> RasterGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct RasterListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _project_id: String, _tags: Option, _search: Option, @@ -9872,9 +9868,9 @@ pub struct RasterListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterListCall<'a, C, A> {} -impl<'a, C, NC, A> RasterListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10018,7 +10014,7 @@ impl<'a, C, NC, A> RasterListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of a Maps Engine project, used to filter the response. To list all available projects with their IDs, send a Projects: list request. You can also find your project ID as the value of the DashboardPlace:cid URL parameter when signed in to mapsengine.google.com. - pub fn project_id(mut self, new_value: &str) -> RasterListCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> RasterListCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -10026,7 +10022,7 @@ impl<'a, C, NC, A> RasterListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// A comma separated list of tags. Returned assets will contain all the tags from the list. - pub fn tags(mut self, new_value: &str) -> RasterListCall<'a, C, NC, A> { + pub fn tags(mut self, new_value: &str) -> RasterListCall<'a, C, A> { self._tags = Some(new_value.to_string()); self } @@ -10034,7 +10030,7 @@ impl<'a, C, NC, A> RasterListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// An unstructured search string used to filter the set of results based on asset metadata. - pub fn search(mut self, new_value: &str) -> RasterListCall<'a, C, NC, A> { + pub fn search(mut self, new_value: &str) -> RasterListCall<'a, C, A> { self._search = Some(new_value.to_string()); self } @@ -10042,14 +10038,14 @@ impl<'a, C, NC, A> RasterListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The role parameter indicates that the response should only contain assets where the current user has the specified level of access. - pub fn role(mut self, new_value: &str) -> RasterListCall<'a, C, NC, A> { + pub fn role(mut self, new_value: &str) -> RasterListCall<'a, C, A> { self._role = Some(new_value.to_string()); self } /// Sets the *processing status* query property to the given value. /// /// - pub fn processing_status(mut self, new_value: &str) -> RasterListCall<'a, C, NC, A> { + pub fn processing_status(mut self, new_value: &str) -> RasterListCall<'a, C, A> { self._processing_status = Some(new_value.to_string()); self } @@ -10057,7 +10053,7 @@ impl<'a, C, NC, A> RasterListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The continuation token, used to page through large result sets. To get the next page of results, set this parameter to the value of nextPageToken from the previous response. - pub fn page_token(mut self, new_value: &str) -> RasterListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> RasterListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -10065,7 +10061,7 @@ impl<'a, C, NC, A> RasterListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been modified at or before this time. - pub fn modified_before(mut self, new_value: &str) -> RasterListCall<'a, C, NC, A> { + pub fn modified_before(mut self, new_value: &str) -> RasterListCall<'a, C, A> { self._modified_before = Some(new_value.to_string()); self } @@ -10073,7 +10069,7 @@ impl<'a, C, NC, A> RasterListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been modified at or after this time. - pub fn modified_after(mut self, new_value: &str) -> RasterListCall<'a, C, NC, A> { + pub fn modified_after(mut self, new_value: &str) -> RasterListCall<'a, C, A> { self._modified_after = Some(new_value.to_string()); self } @@ -10081,7 +10077,7 @@ impl<'a, C, NC, A> RasterListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The maximum number of items to include in a single response page. The maximum supported value is 100. - pub fn max_results(mut self, new_value: u32) -> RasterListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> RasterListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -10089,7 +10085,7 @@ impl<'a, C, NC, A> RasterListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// An email address representing a user. Returned assets that have been created by the user associated with the provided email address. - pub fn creator_email(mut self, new_value: &str) -> RasterListCall<'a, C, NC, A> { + pub fn creator_email(mut self, new_value: &str) -> RasterListCall<'a, C, A> { self._creator_email = Some(new_value.to_string()); self } @@ -10097,7 +10093,7 @@ impl<'a, C, NC, A> RasterListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been created at or before this time. - pub fn created_before(mut self, new_value: &str) -> RasterListCall<'a, C, NC, A> { + pub fn created_before(mut self, new_value: &str) -> RasterListCall<'a, C, A> { self._created_before = Some(new_value.to_string()); self } @@ -10105,7 +10101,7 @@ impl<'a, C, NC, A> RasterListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been created at or after this time. - pub fn created_after(mut self, new_value: &str) -> RasterListCall<'a, C, NC, A> { + pub fn created_after(mut self, new_value: &str) -> RasterListCall<'a, C, A> { self._created_after = Some(new_value.to_string()); self } @@ -10113,7 +10109,7 @@ impl<'a, C, NC, A> RasterListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// A bounding box, expressed as "west,south,east,north". If set, only assets which intersect this bounding box will be returned. - pub fn bbox(mut self, new_value: &str) -> RasterListCall<'a, C, NC, A> { + pub fn bbox(mut self, new_value: &str) -> RasterListCall<'a, C, A> { self._bbox = Some(new_value.to_string()); self } @@ -10124,7 +10120,7 @@ impl<'a, C, NC, A> RasterListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10145,7 +10141,7 @@ impl<'a, C, NC, A> RasterListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10162,7 +10158,7 @@ impl<'a, C, NC, A> RasterListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10206,19 +10202,19 @@ impl<'a, C, NC, A> RasterListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct RasterUploadCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterUploadCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: Raster, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterUploadCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterUploadCall<'a, C, A> {} -impl<'a, C, NC, A> RasterUploadCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterUploadCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10332,7 +10328,7 @@ impl<'a, C, NC, A> RasterUploadCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Raster) -> RasterUploadCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Raster) -> RasterUploadCall<'a, C, A> { self._request = new_value.clone(); self } @@ -10343,7 +10339,7 @@ impl<'a, C, NC, A> RasterUploadCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterUploadCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterUploadCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10364,7 +10360,7 @@ impl<'a, C, NC, A> RasterUploadCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterUploadCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterUploadCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10381,7 +10377,7 @@ impl<'a, C, NC, A> RasterUploadCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterUploadCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterUploadCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10421,10 +10417,10 @@ impl<'a, C, NC, A> RasterUploadCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct RasterParentListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterParentListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _page_token: Option, _max_results: Option, @@ -10433,9 +10429,9 @@ pub struct RasterParentListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterParentListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterParentListCall<'a, C, A> {} -impl<'a, C, NC, A> RasterParentListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterParentListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10573,7 +10569,7 @@ impl<'a, C, NC, A> RasterParentListCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID of the rasters whose parents will be listed. - pub fn id(mut self, new_value: &str) -> RasterParentListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> RasterParentListCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -10581,7 +10577,7 @@ impl<'a, C, NC, A> RasterParentListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The continuation token, used to page through large result sets. To get the next page of results, set this parameter to the value of nextPageToken from the previous response. - pub fn page_token(mut self, new_value: &str) -> RasterParentListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> RasterParentListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -10589,7 +10585,7 @@ impl<'a, C, NC, A> RasterParentListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The maximum number of items to include in a single response page. The maximum supported value is 50. - pub fn max_results(mut self, new_value: u32) -> RasterParentListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> RasterParentListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -10600,7 +10596,7 @@ impl<'a, C, NC, A> RasterParentListCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterParentListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterParentListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10621,7 +10617,7 @@ impl<'a, C, NC, A> RasterParentListCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterParentListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterParentListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10638,7 +10634,7 @@ impl<'a, C, NC, A> RasterParentListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterParentListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterParentListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10676,19 +10672,19 @@ impl<'a, C, NC, A> RasterParentListCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct AssetPermissionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AssetPermissionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AssetPermissionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AssetPermissionListCall<'a, C, A> {} -impl<'a, C, NC, A> AssetPermissionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AssetPermissionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10820,7 +10816,7 @@ impl<'a, C, NC, A> AssetPermissionListCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The ID of the asset whose permissions will be listed. - pub fn id(mut self, new_value: &str) -> AssetPermissionListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> AssetPermissionListCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -10831,7 +10827,7 @@ impl<'a, C, NC, A> AssetPermissionListCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AssetPermissionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AssetPermissionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10852,7 +10848,7 @@ impl<'a, C, NC, A> AssetPermissionListCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AssetPermissionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AssetPermissionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10869,7 +10865,7 @@ impl<'a, C, NC, A> AssetPermissionListCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AssetPermissionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AssetPermissionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10920,10 +10916,10 @@ impl<'a, C, NC, A> AssetPermissionListCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct AssetListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AssetListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _type_: Option, _tags: Option, _search: Option, @@ -10942,9 +10938,9 @@ pub struct AssetListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AssetListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AssetListCall<'a, C, A> {} -impl<'a, C, NC, A> AssetListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AssetListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11088,7 +11084,7 @@ impl<'a, C, NC, A> AssetListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// A comma separated list of asset types. Returned assets will have one of the types from the provided list. Supported values are 'map', 'layer', 'rasterCollection' and 'table'. - pub fn type_(mut self, new_value: &str) -> AssetListCall<'a, C, NC, A> { + pub fn type_(mut self, new_value: &str) -> AssetListCall<'a, C, A> { self._type_ = Some(new_value.to_string()); self } @@ -11096,7 +11092,7 @@ impl<'a, C, NC, A> AssetListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// A comma separated list of tags. Returned assets will contain all the tags from the list. - pub fn tags(mut self, new_value: &str) -> AssetListCall<'a, C, NC, A> { + pub fn tags(mut self, new_value: &str) -> AssetListCall<'a, C, A> { self._tags = Some(new_value.to_string()); self } @@ -11104,7 +11100,7 @@ impl<'a, C, NC, A> AssetListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// An unstructured search string used to filter the set of results based on asset metadata. - pub fn search(mut self, new_value: &str) -> AssetListCall<'a, C, NC, A> { + pub fn search(mut self, new_value: &str) -> AssetListCall<'a, C, A> { self._search = Some(new_value.to_string()); self } @@ -11112,7 +11108,7 @@ impl<'a, C, NC, A> AssetListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The role parameter indicates that the response should only contain assets where the current user has the specified level of access. - pub fn role(mut self, new_value: &str) -> AssetListCall<'a, C, NC, A> { + pub fn role(mut self, new_value: &str) -> AssetListCall<'a, C, A> { self._role = Some(new_value.to_string()); self } @@ -11120,7 +11116,7 @@ impl<'a, C, NC, A> AssetListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The ID of a Maps Engine project, used to filter the response. To list all available projects with their IDs, send a Projects: list request. You can also find your project ID as the value of the DashboardPlace:cid URL parameter when signed in to mapsengine.google.com. - pub fn project_id(mut self, new_value: &str) -> AssetListCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> AssetListCall<'a, C, A> { self._project_id = Some(new_value.to_string()); self } @@ -11128,7 +11124,7 @@ impl<'a, C, NC, A> AssetListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The continuation token, used to page through large result sets. To get the next page of results, set this parameter to the value of nextPageToken from the previous response. - pub fn page_token(mut self, new_value: &str) -> AssetListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AssetListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -11136,7 +11132,7 @@ impl<'a, C, NC, A> AssetListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been modified at or before this time. - pub fn modified_before(mut self, new_value: &str) -> AssetListCall<'a, C, NC, A> { + pub fn modified_before(mut self, new_value: &str) -> AssetListCall<'a, C, A> { self._modified_before = Some(new_value.to_string()); self } @@ -11144,7 +11140,7 @@ impl<'a, C, NC, A> AssetListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been modified at or after this time. - pub fn modified_after(mut self, new_value: &str) -> AssetListCall<'a, C, NC, A> { + pub fn modified_after(mut self, new_value: &str) -> AssetListCall<'a, C, A> { self._modified_after = Some(new_value.to_string()); self } @@ -11152,7 +11148,7 @@ impl<'a, C, NC, A> AssetListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The maximum number of items to include in a single response page. The maximum supported value is 100. - pub fn max_results(mut self, new_value: u32) -> AssetListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> AssetListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -11160,7 +11156,7 @@ impl<'a, C, NC, A> AssetListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// An email address representing a user. Returned assets that have been created by the user associated with the provided email address. - pub fn creator_email(mut self, new_value: &str) -> AssetListCall<'a, C, NC, A> { + pub fn creator_email(mut self, new_value: &str) -> AssetListCall<'a, C, A> { self._creator_email = Some(new_value.to_string()); self } @@ -11168,7 +11164,7 @@ impl<'a, C, NC, A> AssetListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been created at or before this time. - pub fn created_before(mut self, new_value: &str) -> AssetListCall<'a, C, NC, A> { + pub fn created_before(mut self, new_value: &str) -> AssetListCall<'a, C, A> { self._created_before = Some(new_value.to_string()); self } @@ -11176,7 +11172,7 @@ impl<'a, C, NC, A> AssetListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been created at or after this time. - pub fn created_after(mut self, new_value: &str) -> AssetListCall<'a, C, NC, A> { + pub fn created_after(mut self, new_value: &str) -> AssetListCall<'a, C, A> { self._created_after = Some(new_value.to_string()); self } @@ -11184,7 +11180,7 @@ impl<'a, C, NC, A> AssetListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// A bounding box, expressed as "west,south,east,north". If set, only assets which intersect this bounding box will be returned. - pub fn bbox(mut self, new_value: &str) -> AssetListCall<'a, C, NC, A> { + pub fn bbox(mut self, new_value: &str) -> AssetListCall<'a, C, A> { self._bbox = Some(new_value.to_string()); self } @@ -11195,7 +11191,7 @@ impl<'a, C, NC, A> AssetListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AssetListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AssetListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11216,7 +11212,7 @@ impl<'a, C, NC, A> AssetListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AssetListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AssetListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11233,7 +11229,7 @@ impl<'a, C, NC, A> AssetListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AssetListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AssetListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11271,19 +11267,19 @@ impl<'a, C, NC, A> AssetListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct AssetGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AssetGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AssetGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AssetGetCall<'a, C, A> {} -impl<'a, C, NC, A> AssetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AssetGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11415,7 +11411,7 @@ impl<'a, C, NC, A> AssetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The ID of the asset. - pub fn id(mut self, new_value: &str) -> AssetGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> AssetGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -11426,7 +11422,7 @@ impl<'a, C, NC, A> AssetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AssetGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AssetGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11447,7 +11443,7 @@ impl<'a, C, NC, A> AssetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AssetGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AssetGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11464,7 +11460,7 @@ impl<'a, C, NC, A> AssetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AssetGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AssetGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11504,10 +11500,10 @@ impl<'a, C, NC, A> AssetGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct AssetParentListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AssetParentListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _page_token: Option, _max_results: Option, @@ -11516,9 +11512,9 @@ pub struct AssetParentListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AssetParentListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AssetParentListCall<'a, C, A> {} -impl<'a, C, NC, A> AssetParentListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AssetParentListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11656,7 +11652,7 @@ impl<'a, C, NC, A> AssetParentListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the asset whose parents will be listed. - pub fn id(mut self, new_value: &str) -> AssetParentListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> AssetParentListCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -11664,7 +11660,7 @@ impl<'a, C, NC, A> AssetParentListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The continuation token, used to page through large result sets. To get the next page of results, set this parameter to the value of nextPageToken from the previous response. - pub fn page_token(mut self, new_value: &str) -> AssetParentListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AssetParentListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -11672,7 +11668,7 @@ impl<'a, C, NC, A> AssetParentListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The maximum number of items to include in a single response page. The maximum supported value is 50. - pub fn max_results(mut self, new_value: u32) -> AssetParentListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> AssetParentListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -11683,7 +11679,7 @@ impl<'a, C, NC, A> AssetParentListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AssetParentListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AssetParentListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11704,7 +11700,7 @@ impl<'a, C, NC, A> AssetParentListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AssetParentListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AssetParentListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11721,7 +11717,7 @@ impl<'a, C, NC, A> AssetParentListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AssetParentListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AssetParentListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11759,19 +11755,19 @@ impl<'a, C, NC, A> AssetParentListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct TableDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> TableDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11892,7 +11888,7 @@ impl<'a, C, NC, A> TableDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the table. Only the table creator or project owner are permitted to delete. If the table is included in a layer, the request will fail. Remove it from all layers prior to deleting. - pub fn id(mut self, new_value: &str) -> TableDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> TableDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -11903,7 +11899,7 @@ impl<'a, C, NC, A> TableDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11924,7 +11920,7 @@ impl<'a, C, NC, A> TableDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11941,7 +11937,7 @@ impl<'a, C, NC, A> TableDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11981,10 +11977,10 @@ impl<'a, C, NC, A> TableDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .upload_resumable(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct TableFileInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableFileInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _filename: String, _delegate: Option<&'a mut Delegate>, @@ -11992,9 +11988,9 @@ pub struct TableFileInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableFileInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableFileInsertCall<'a, C, A> {} -impl<'a, C, NC, A> TableFileInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableFileInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12225,7 +12221,7 @@ impl<'a, C, NC, A> TableFileInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the table asset. - pub fn id(mut self, new_value: &str) -> TableFileInsertCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> TableFileInsertCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -12235,7 +12231,7 @@ impl<'a, C, NC, A> TableFileInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The file name of this uploaded file. - pub fn filename(mut self, new_value: &str) -> TableFileInsertCall<'a, C, NC, A> { + pub fn filename(mut self, new_value: &str) -> TableFileInsertCall<'a, C, A> { self._filename = new_value.to_string(); self } @@ -12246,7 +12242,7 @@ impl<'a, C, NC, A> TableFileInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableFileInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableFileInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12267,7 +12263,7 @@ impl<'a, C, NC, A> TableFileInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableFileInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableFileInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12284,7 +12280,7 @@ impl<'a, C, NC, A> TableFileInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableFileInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableFileInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12336,10 +12332,10 @@ impl<'a, C, NC, A> TableFileInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct TableFeatureBatchInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableFeatureBatchInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: FeaturesBatchInsertRequest, _id: String, _delegate: Option<&'a mut Delegate>, @@ -12347,9 +12343,9 @@ pub struct TableFeatureBatchInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableFeatureBatchInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableFeatureBatchInsertCall<'a, C, A> {} -impl<'a, C, NC, A> TableFeatureBatchInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableFeatureBatchInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12477,7 +12473,7 @@ impl<'a, C, NC, A> TableFeatureBatchInsertCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &FeaturesBatchInsertRequest) -> TableFeatureBatchInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &FeaturesBatchInsertRequest) -> TableFeatureBatchInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -12487,7 +12483,7 @@ impl<'a, C, NC, A> TableFeatureBatchInsertCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The ID of the table to append the features to. - pub fn id(mut self, new_value: &str) -> TableFeatureBatchInsertCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> TableFeatureBatchInsertCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -12498,7 +12494,7 @@ impl<'a, C, NC, A> TableFeatureBatchInsertCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableFeatureBatchInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableFeatureBatchInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12519,7 +12515,7 @@ impl<'a, C, NC, A> TableFeatureBatchInsertCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableFeatureBatchInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableFeatureBatchInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12536,7 +12532,7 @@ impl<'a, C, NC, A> TableFeatureBatchInsertCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableFeatureBatchInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableFeatureBatchInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12587,10 +12583,10 @@ impl<'a, C, NC, A> TableFeatureBatchInsertCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct TableListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _tags: Option, _search: Option, _role: Option, @@ -12609,9 +12605,9 @@ pub struct TableListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableListCall<'a, C, A> {} -impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12755,7 +12751,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// A comma separated list of tags. Returned assets will contain all the tags from the list. - pub fn tags(mut self, new_value: &str) -> TableListCall<'a, C, NC, A> { + pub fn tags(mut self, new_value: &str) -> TableListCall<'a, C, A> { self._tags = Some(new_value.to_string()); self } @@ -12763,7 +12759,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// An unstructured search string used to filter the set of results based on asset metadata. - pub fn search(mut self, new_value: &str) -> TableListCall<'a, C, NC, A> { + pub fn search(mut self, new_value: &str) -> TableListCall<'a, C, A> { self._search = Some(new_value.to_string()); self } @@ -12771,7 +12767,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The role parameter indicates that the response should only contain assets where the current user has the specified level of access. - pub fn role(mut self, new_value: &str) -> TableListCall<'a, C, NC, A> { + pub fn role(mut self, new_value: &str) -> TableListCall<'a, C, A> { self._role = Some(new_value.to_string()); self } @@ -12779,14 +12775,14 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The ID of a Maps Engine project, used to filter the response. To list all available projects with their IDs, send a Projects: list request. You can also find your project ID as the value of the DashboardPlace:cid URL parameter when signed in to mapsengine.google.com. - pub fn project_id(mut self, new_value: &str) -> TableListCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> TableListCall<'a, C, A> { self._project_id = Some(new_value.to_string()); self } /// Sets the *processing status* query property to the given value. /// /// - pub fn processing_status(mut self, new_value: &str) -> TableListCall<'a, C, NC, A> { + pub fn processing_status(mut self, new_value: &str) -> TableListCall<'a, C, A> { self._processing_status = Some(new_value.to_string()); self } @@ -12794,7 +12790,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The continuation token, used to page through large result sets. To get the next page of results, set this parameter to the value of nextPageToken from the previous response. - pub fn page_token(mut self, new_value: &str) -> TableListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TableListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -12802,7 +12798,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been modified at or before this time. - pub fn modified_before(mut self, new_value: &str) -> TableListCall<'a, C, NC, A> { + pub fn modified_before(mut self, new_value: &str) -> TableListCall<'a, C, A> { self._modified_before = Some(new_value.to_string()); self } @@ -12810,7 +12806,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been modified at or after this time. - pub fn modified_after(mut self, new_value: &str) -> TableListCall<'a, C, NC, A> { + pub fn modified_after(mut self, new_value: &str) -> TableListCall<'a, C, A> { self._modified_after = Some(new_value.to_string()); self } @@ -12818,7 +12814,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The maximum number of items to include in a single response page. The maximum supported value is 100. - pub fn max_results(mut self, new_value: u32) -> TableListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> TableListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -12826,7 +12822,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// An email address representing a user. Returned assets that have been created by the user associated with the provided email address. - pub fn creator_email(mut self, new_value: &str) -> TableListCall<'a, C, NC, A> { + pub fn creator_email(mut self, new_value: &str) -> TableListCall<'a, C, A> { self._creator_email = Some(new_value.to_string()); self } @@ -12834,7 +12830,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been created at or before this time. - pub fn created_before(mut self, new_value: &str) -> TableListCall<'a, C, NC, A> { + pub fn created_before(mut self, new_value: &str) -> TableListCall<'a, C, A> { self._created_before = Some(new_value.to_string()); self } @@ -12842,7 +12838,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been created at or after this time. - pub fn created_after(mut self, new_value: &str) -> TableListCall<'a, C, NC, A> { + pub fn created_after(mut self, new_value: &str) -> TableListCall<'a, C, A> { self._created_after = Some(new_value.to_string()); self } @@ -12850,7 +12846,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// A bounding box, expressed as "west,south,east,north". If set, only assets which intersect this bounding box will be returned. - pub fn bbox(mut self, new_value: &str) -> TableListCall<'a, C, NC, A> { + pub fn bbox(mut self, new_value: &str) -> TableListCall<'a, C, A> { self._bbox = Some(new_value.to_string()); self } @@ -12861,7 +12857,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12882,7 +12878,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12899,7 +12895,7 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12938,10 +12934,10 @@ impl<'a, C, NC, A> TableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct TableGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _version: Option, _delegate: Option<&'a mut Delegate>, @@ -12949,9 +12945,9 @@ pub struct TableGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableGetCall<'a, C, A> {} -impl<'a, C, NC, A> TableGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13086,14 +13082,14 @@ impl<'a, C, NC, A> TableGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The ID of the table. - pub fn id(mut self, new_value: &str) -> TableGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> TableGetCall<'a, C, A> { self._id = new_value.to_string(); self } /// Sets the *version* query property to the given value. /// /// - pub fn version(mut self, new_value: &str) -> TableGetCall<'a, C, NC, A> { + pub fn version(mut self, new_value: &str) -> TableGetCall<'a, C, A> { self._version = Some(new_value.to_string()); self } @@ -13104,7 +13100,7 @@ impl<'a, C, NC, A> TableGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13125,7 +13121,7 @@ impl<'a, C, NC, A> TableGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13142,7 +13138,7 @@ impl<'a, C, NC, A> TableGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13186,10 +13182,10 @@ impl<'a, C, NC, A> TableGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct TableFeatureBatchDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableFeatureBatchDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: FeaturesBatchDeleteRequest, _id: String, _delegate: Option<&'a mut Delegate>, @@ -13197,9 +13193,9 @@ pub struct TableFeatureBatchDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableFeatureBatchDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableFeatureBatchDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> TableFeatureBatchDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableFeatureBatchDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13327,7 +13323,7 @@ impl<'a, C, NC, A> TableFeatureBatchDeleteCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &FeaturesBatchDeleteRequest) -> TableFeatureBatchDeleteCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &FeaturesBatchDeleteRequest) -> TableFeatureBatchDeleteCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13337,7 +13333,7 @@ impl<'a, C, NC, A> TableFeatureBatchDeleteCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The ID of the table that contains the features to be deleted. - pub fn id(mut self, new_value: &str) -> TableFeatureBatchDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> TableFeatureBatchDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -13348,7 +13344,7 @@ impl<'a, C, NC, A> TableFeatureBatchDeleteCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableFeatureBatchDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableFeatureBatchDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13369,7 +13365,7 @@ impl<'a, C, NC, A> TableFeatureBatchDeleteCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableFeatureBatchDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableFeatureBatchDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13386,7 +13382,7 @@ impl<'a, C, NC, A> TableFeatureBatchDeleteCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableFeatureBatchDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableFeatureBatchDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13433,10 +13429,10 @@ impl<'a, C, NC, A> TableFeatureBatchDeleteCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct TableFeatureListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableFeatureListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _where_: Option, _version: Option, @@ -13452,9 +13448,9 @@ pub struct TableFeatureListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableFeatureListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableFeatureListCall<'a, C, A> {} -impl<'a, C, NC, A> TableFeatureListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableFeatureListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13613,7 +13609,7 @@ impl<'a, C, NC, A> TableFeatureListCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The ID of the table to which these features belong. - pub fn id(mut self, new_value: &str) -> TableFeatureListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> TableFeatureListCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -13621,7 +13617,7 @@ impl<'a, C, NC, A> TableFeatureListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// An SQL-like predicate used to filter results. - pub fn where_(mut self, new_value: &str) -> TableFeatureListCall<'a, C, NC, A> { + pub fn where_(mut self, new_value: &str) -> TableFeatureListCall<'a, C, A> { self._where_ = Some(new_value.to_string()); self } @@ -13629,7 +13625,7 @@ impl<'a, C, NC, A> TableFeatureListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The table version to access. See Accessing Public Data for information. - pub fn version(mut self, new_value: &str) -> TableFeatureListCall<'a, C, NC, A> { + pub fn version(mut self, new_value: &str) -> TableFeatureListCall<'a, C, A> { self._version = Some(new_value.to_string()); self } @@ -13637,7 +13633,7 @@ impl<'a, C, NC, A> TableFeatureListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// A SQL-like projection clause used to specify returned properties. If this parameter is not included, all properties are returned. - pub fn select(mut self, new_value: &str) -> TableFeatureListCall<'a, C, NC, A> { + pub fn select(mut self, new_value: &str) -> TableFeatureListCall<'a, C, A> { self._select = Some(new_value.to_string()); self } @@ -13645,7 +13641,7 @@ impl<'a, C, NC, A> TableFeatureListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The continuation token, used to page through large result sets. To get the next page of results, set this parameter to the value of nextPageToken from the previous response. - pub fn page_token(mut self, new_value: &str) -> TableFeatureListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TableFeatureListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -13653,7 +13649,7 @@ impl<'a, C, NC, A> TableFeatureListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// An SQL-like order by clause used to sort results. If this parameter is not included, the order of features is undefined. - pub fn order_by(mut self, new_value: &str) -> TableFeatureListCall<'a, C, NC, A> { + pub fn order_by(mut self, new_value: &str) -> TableFeatureListCall<'a, C, A> { self._order_by = Some(new_value.to_string()); self } @@ -13661,7 +13657,7 @@ impl<'a, C, NC, A> TableFeatureListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The maximum number of items to include in the response, used for paging. The maximum supported value is 1000. - pub fn max_results(mut self, new_value: u32) -> TableFeatureListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> TableFeatureListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -13669,7 +13665,7 @@ impl<'a, C, NC, A> TableFeatureListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The total number of features to return from the query, irrespective of the number of pages. - pub fn limit(mut self, new_value: u32) -> TableFeatureListCall<'a, C, NC, A> { + pub fn limit(mut self, new_value: u32) -> TableFeatureListCall<'a, C, A> { self._limit = Some(new_value); self } @@ -13677,7 +13673,7 @@ impl<'a, C, NC, A> TableFeatureListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// A geometry literal that specifies the spatial restriction of the query. - pub fn intersects(mut self, new_value: &str) -> TableFeatureListCall<'a, C, NC, A> { + pub fn intersects(mut self, new_value: &str) -> TableFeatureListCall<'a, C, A> { self._intersects = Some(new_value.to_string()); self } @@ -13685,7 +13681,7 @@ impl<'a, C, NC, A> TableFeatureListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// A comma separated list of optional data to include. Optional data available: schema. - pub fn include(mut self, new_value: &str) -> TableFeatureListCall<'a, C, NC, A> { + pub fn include(mut self, new_value: &str) -> TableFeatureListCall<'a, C, A> { self._include = Some(new_value.to_string()); self } @@ -13696,7 +13692,7 @@ impl<'a, C, NC, A> TableFeatureListCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableFeatureListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableFeatureListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13717,7 +13713,7 @@ impl<'a, C, NC, A> TableFeatureListCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableFeatureListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableFeatureListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13734,7 +13730,7 @@ impl<'a, C, NC, A> TableFeatureListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableFeatureListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableFeatureListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13772,19 +13768,19 @@ impl<'a, C, NC, A> TableFeatureListCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct TableProcesCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableProcesCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableProcesCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableProcesCall<'a, C, A> {} -impl<'a, C, NC, A> TableProcesCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableProcesCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13916,7 +13912,7 @@ impl<'a, C, NC, A> TableProcesCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the table. - pub fn id(mut self, new_value: &str) -> TableProcesCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> TableProcesCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -13927,7 +13923,7 @@ impl<'a, C, NC, A> TableProcesCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableProcesCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableProcesCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13948,7 +13944,7 @@ impl<'a, C, NC, A> TableProcesCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableProcesCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableProcesCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13965,7 +13961,7 @@ impl<'a, C, NC, A> TableProcesCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableProcesCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableProcesCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14005,10 +14001,10 @@ impl<'a, C, NC, A> TableProcesCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct TableParentListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableParentListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _page_token: Option, _max_results: Option, @@ -14017,9 +14013,9 @@ pub struct TableParentListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableParentListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableParentListCall<'a, C, A> {} -impl<'a, C, NC, A> TableParentListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableParentListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14157,7 +14153,7 @@ impl<'a, C, NC, A> TableParentListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the table whose parents will be listed. - pub fn id(mut self, new_value: &str) -> TableParentListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> TableParentListCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -14165,7 +14161,7 @@ impl<'a, C, NC, A> TableParentListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The continuation token, used to page through large result sets. To get the next page of results, set this parameter to the value of nextPageToken from the previous response. - pub fn page_token(mut self, new_value: &str) -> TableParentListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TableParentListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -14173,7 +14169,7 @@ impl<'a, C, NC, A> TableParentListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The maximum number of items to include in a single response page. The maximum supported value is 50. - pub fn max_results(mut self, new_value: u32) -> TableParentListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> TableParentListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -14184,7 +14180,7 @@ impl<'a, C, NC, A> TableParentListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableParentListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableParentListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14205,7 +14201,7 @@ impl<'a, C, NC, A> TableParentListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableParentListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableParentListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14222,7 +14218,7 @@ impl<'a, C, NC, A> TableParentListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableParentListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableParentListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14268,10 +14264,10 @@ impl<'a, C, NC, A> TableParentListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct TablePermissionBatchUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TablePermissionBatchUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: PermissionsBatchUpdateRequest, _id: String, _delegate: Option<&'a mut Delegate>, @@ -14279,9 +14275,9 @@ pub struct TablePermissionBatchUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TablePermissionBatchUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TablePermissionBatchUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> TablePermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TablePermissionBatchUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14420,7 +14416,7 @@ impl<'a, C, NC, A> TablePermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PermissionsBatchUpdateRequest) -> TablePermissionBatchUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PermissionsBatchUpdateRequest) -> TablePermissionBatchUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -14430,7 +14426,7 @@ impl<'a, C, NC, A> TablePermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The ID of the asset to which permissions will be added. - pub fn id(mut self, new_value: &str) -> TablePermissionBatchUpdateCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> TablePermissionBatchUpdateCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -14441,7 +14437,7 @@ impl<'a, C, NC, A> TablePermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TablePermissionBatchUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TablePermissionBatchUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14462,7 +14458,7 @@ impl<'a, C, NC, A> TablePermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TablePermissionBatchUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TablePermissionBatchUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14479,7 +14475,7 @@ impl<'a, C, NC, A> TablePermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TablePermissionBatchUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TablePermissionBatchUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14525,19 +14521,19 @@ impl<'a, C, NC, A> TablePermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct TableUploadCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableUploadCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: Table, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableUploadCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableUploadCall<'a, C, A> {} -impl<'a, C, NC, A> TableUploadCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableUploadCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14651,7 +14647,7 @@ impl<'a, C, NC, A> TableUploadCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Table) -> TableUploadCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Table) -> TableUploadCall<'a, C, A> { self._request = new_value.clone(); self } @@ -14662,7 +14658,7 @@ impl<'a, C, NC, A> TableUploadCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableUploadCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableUploadCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14683,7 +14679,7 @@ impl<'a, C, NC, A> TableUploadCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableUploadCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableUploadCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14700,7 +14696,7 @@ impl<'a, C, NC, A> TableUploadCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableUploadCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableUploadCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14758,10 +14754,10 @@ impl<'a, C, NC, A> TableUploadCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct TableFeatureBatchPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableFeatureBatchPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: FeaturesBatchPatchRequest, _id: String, _delegate: Option<&'a mut Delegate>, @@ -14769,9 +14765,9 @@ pub struct TableFeatureBatchPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableFeatureBatchPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableFeatureBatchPatchCall<'a, C, A> {} -impl<'a, C, NC, A> TableFeatureBatchPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableFeatureBatchPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14899,7 +14895,7 @@ impl<'a, C, NC, A> TableFeatureBatchPatchCall<'a, C, NC, A> where NC: hyper::net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &FeaturesBatchPatchRequest) -> TableFeatureBatchPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &FeaturesBatchPatchRequest) -> TableFeatureBatchPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -14909,7 +14905,7 @@ impl<'a, C, NC, A> TableFeatureBatchPatchCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The ID of the table containing the features to be patched. - pub fn id(mut self, new_value: &str) -> TableFeatureBatchPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> TableFeatureBatchPatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -14920,7 +14916,7 @@ impl<'a, C, NC, A> TableFeatureBatchPatchCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableFeatureBatchPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableFeatureBatchPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14941,7 +14937,7 @@ impl<'a, C, NC, A> TableFeatureBatchPatchCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableFeatureBatchPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableFeatureBatchPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14958,7 +14954,7 @@ impl<'a, C, NC, A> TableFeatureBatchPatchCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableFeatureBatchPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableFeatureBatchPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15002,10 +14998,10 @@ impl<'a, C, NC, A> TableFeatureBatchPatchCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct TablePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TablePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: Table, _id: String, _delegate: Option<&'a mut Delegate>, @@ -15013,9 +15009,9 @@ pub struct TablePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TablePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TablePatchCall<'a, C, A> {} -impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TablePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15143,7 +15139,7 @@ impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Table) -> TablePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Table) -> TablePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -15153,7 +15149,7 @@ impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the table. - pub fn id(mut self, new_value: &str) -> TablePatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> TablePatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -15164,7 +15160,7 @@ impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TablePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TablePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15185,7 +15181,7 @@ impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TablePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TablePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15202,7 +15198,7 @@ impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TablePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TablePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15246,10 +15242,10 @@ impl<'a, C, NC, A> TablePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct TablePermissionBatchDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TablePermissionBatchDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: PermissionsBatchDeleteRequest, _id: String, _delegate: Option<&'a mut Delegate>, @@ -15257,9 +15253,9 @@ pub struct TablePermissionBatchDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TablePermissionBatchDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TablePermissionBatchDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> TablePermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TablePermissionBatchDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15398,7 +15394,7 @@ impl<'a, C, NC, A> TablePermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PermissionsBatchDeleteRequest) -> TablePermissionBatchDeleteCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PermissionsBatchDeleteRequest) -> TablePermissionBatchDeleteCall<'a, C, A> { self._request = new_value.clone(); self } @@ -15408,7 +15404,7 @@ impl<'a, C, NC, A> TablePermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The ID of the asset from which permissions will be removed. - pub fn id(mut self, new_value: &str) -> TablePermissionBatchDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> TablePermissionBatchDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -15419,7 +15415,7 @@ impl<'a, C, NC, A> TablePermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TablePermissionBatchDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TablePermissionBatchDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15440,7 +15436,7 @@ impl<'a, C, NC, A> TablePermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TablePermissionBatchDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TablePermissionBatchDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15457,7 +15453,7 @@ impl<'a, C, NC, A> TablePermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TablePermissionBatchDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TablePermissionBatchDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15501,19 +15497,19 @@ impl<'a, C, NC, A> TablePermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct TableCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: Table, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableCreateCall<'a, C, A> {} -impl<'a, C, NC, A> TableCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15627,7 +15623,7 @@ impl<'a, C, NC, A> TableCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Table) -> TableCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Table) -> TableCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -15638,7 +15634,7 @@ impl<'a, C, NC, A> TableCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15659,7 +15655,7 @@ impl<'a, C, NC, A> TableCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15676,7 +15672,7 @@ impl<'a, C, NC, A> TableCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15714,19 +15710,19 @@ impl<'a, C, NC, A> TableCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct TablePermissionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TablePermissionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TablePermissionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TablePermissionListCall<'a, C, A> {} -impl<'a, C, NC, A> TablePermissionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TablePermissionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15858,7 +15854,7 @@ impl<'a, C, NC, A> TablePermissionListCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The ID of the asset whose permissions will be listed. - pub fn id(mut self, new_value: &str) -> TablePermissionListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> TablePermissionListCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -15869,7 +15865,7 @@ impl<'a, C, NC, A> TablePermissionListCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TablePermissionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TablePermissionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15890,7 +15886,7 @@ impl<'a, C, NC, A> TablePermissionListCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TablePermissionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TablePermissionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15907,7 +15903,7 @@ impl<'a, C, NC, A> TablePermissionListCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TablePermissionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TablePermissionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15947,10 +15943,10 @@ impl<'a, C, NC, A> TablePermissionListCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct TableFeatureGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TableFeatureGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _table_id: String, _id: String, _version: Option, @@ -15960,9 +15956,9 @@ pub struct TableFeatureGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TableFeatureGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TableFeatureGetCall<'a, C, A> {} -impl<'a, C, NC, A> TableFeatureGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TableFeatureGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16101,7 +16097,7 @@ impl<'a, C, NC, A> TableFeatureGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the table. - pub fn table_id(mut self, new_value: &str) -> TableFeatureGetCall<'a, C, NC, A> { + pub fn table_id(mut self, new_value: &str) -> TableFeatureGetCall<'a, C, A> { self._table_id = new_value.to_string(); self } @@ -16111,7 +16107,7 @@ impl<'a, C, NC, A> TableFeatureGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the feature to get. - pub fn id(mut self, new_value: &str) -> TableFeatureGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> TableFeatureGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -16119,7 +16115,7 @@ impl<'a, C, NC, A> TableFeatureGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The table version to access. See Accessing Public Data for information. - pub fn version(mut self, new_value: &str) -> TableFeatureGetCall<'a, C, NC, A> { + pub fn version(mut self, new_value: &str) -> TableFeatureGetCall<'a, C, A> { self._version = Some(new_value.to_string()); self } @@ -16127,7 +16123,7 @@ impl<'a, C, NC, A> TableFeatureGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// A SQL-like projection clause used to specify returned properties. If this parameter is not included, all properties are returned. - pub fn select(mut self, new_value: &str) -> TableFeatureGetCall<'a, C, NC, A> { + pub fn select(mut self, new_value: &str) -> TableFeatureGetCall<'a, C, A> { self._select = Some(new_value.to_string()); self } @@ -16138,7 +16134,7 @@ impl<'a, C, NC, A> TableFeatureGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableFeatureGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TableFeatureGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16159,7 +16155,7 @@ impl<'a, C, NC, A> TableFeatureGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TableFeatureGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TableFeatureGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16176,7 +16172,7 @@ impl<'a, C, NC, A> TableFeatureGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TableFeatureGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TableFeatureGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16227,10 +16223,10 @@ impl<'a, C, NC, A> TableFeatureGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct MapListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MapListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _tags: Option, _search: Option, _role: Option, @@ -16249,9 +16245,9 @@ pub struct MapListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MapListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MapListCall<'a, C, A> {} -impl<'a, C, NC, A> MapListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MapListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16395,7 +16391,7 @@ impl<'a, C, NC, A> MapListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// A comma separated list of tags. Returned assets will contain all the tags from the list. - pub fn tags(mut self, new_value: &str) -> MapListCall<'a, C, NC, A> { + pub fn tags(mut self, new_value: &str) -> MapListCall<'a, C, A> { self._tags = Some(new_value.to_string()); self } @@ -16403,7 +16399,7 @@ impl<'a, C, NC, A> MapListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// An unstructured search string used to filter the set of results based on asset metadata. - pub fn search(mut self, new_value: &str) -> MapListCall<'a, C, NC, A> { + pub fn search(mut self, new_value: &str) -> MapListCall<'a, C, A> { self._search = Some(new_value.to_string()); self } @@ -16411,7 +16407,7 @@ impl<'a, C, NC, A> MapListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// The role parameter indicates that the response should only contain assets where the current user has the specified level of access. - pub fn role(mut self, new_value: &str) -> MapListCall<'a, C, NC, A> { + pub fn role(mut self, new_value: &str) -> MapListCall<'a, C, A> { self._role = Some(new_value.to_string()); self } @@ -16419,14 +16415,14 @@ impl<'a, C, NC, A> MapListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// The ID of a Maps Engine project, used to filter the response. To list all available projects with their IDs, send a Projects: list request. You can also find your project ID as the value of the DashboardPlace:cid URL parameter when signed in to mapsengine.google.com. - pub fn project_id(mut self, new_value: &str) -> MapListCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> MapListCall<'a, C, A> { self._project_id = Some(new_value.to_string()); self } /// Sets the *processing status* query property to the given value. /// /// - pub fn processing_status(mut self, new_value: &str) -> MapListCall<'a, C, NC, A> { + pub fn processing_status(mut self, new_value: &str) -> MapListCall<'a, C, A> { self._processing_status = Some(new_value.to_string()); self } @@ -16434,7 +16430,7 @@ impl<'a, C, NC, A> MapListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// The continuation token, used to page through large result sets. To get the next page of results, set this parameter to the value of nextPageToken from the previous response. - pub fn page_token(mut self, new_value: &str) -> MapListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> MapListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -16442,7 +16438,7 @@ impl<'a, C, NC, A> MapListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been modified at or before this time. - pub fn modified_before(mut self, new_value: &str) -> MapListCall<'a, C, NC, A> { + pub fn modified_before(mut self, new_value: &str) -> MapListCall<'a, C, A> { self._modified_before = Some(new_value.to_string()); self } @@ -16450,7 +16446,7 @@ impl<'a, C, NC, A> MapListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been modified at or after this time. - pub fn modified_after(mut self, new_value: &str) -> MapListCall<'a, C, NC, A> { + pub fn modified_after(mut self, new_value: &str) -> MapListCall<'a, C, A> { self._modified_after = Some(new_value.to_string()); self } @@ -16458,7 +16454,7 @@ impl<'a, C, NC, A> MapListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// The maximum number of items to include in a single response page. The maximum supported value is 100. - pub fn max_results(mut self, new_value: u32) -> MapListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> MapListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -16466,7 +16462,7 @@ impl<'a, C, NC, A> MapListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// An email address representing a user. Returned assets that have been created by the user associated with the provided email address. - pub fn creator_email(mut self, new_value: &str) -> MapListCall<'a, C, NC, A> { + pub fn creator_email(mut self, new_value: &str) -> MapListCall<'a, C, A> { self._creator_email = Some(new_value.to_string()); self } @@ -16474,7 +16470,7 @@ impl<'a, C, NC, A> MapListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been created at or before this time. - pub fn created_before(mut self, new_value: &str) -> MapListCall<'a, C, NC, A> { + pub fn created_before(mut self, new_value: &str) -> MapListCall<'a, C, A> { self._created_before = Some(new_value.to_string()); self } @@ -16482,7 +16478,7 @@ impl<'a, C, NC, A> MapListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been created at or after this time. - pub fn created_after(mut self, new_value: &str) -> MapListCall<'a, C, NC, A> { + pub fn created_after(mut self, new_value: &str) -> MapListCall<'a, C, A> { self._created_after = Some(new_value.to_string()); self } @@ -16490,7 +16486,7 @@ impl<'a, C, NC, A> MapListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// A bounding box, expressed as "west,south,east,north". If set, only assets which intersect this bounding box will be returned. - pub fn bbox(mut self, new_value: &str) -> MapListCall<'a, C, NC, A> { + pub fn bbox(mut self, new_value: &str) -> MapListCall<'a, C, A> { self._bbox = Some(new_value.to_string()); self } @@ -16501,7 +16497,7 @@ impl<'a, C, NC, A> MapListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16522,7 +16518,7 @@ impl<'a, C, NC, A> MapListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MapListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MapListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16539,7 +16535,7 @@ impl<'a, C, NC, A> MapListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MapListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MapListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16580,10 +16576,10 @@ impl<'a, C, NC, A> MapListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct MapListPublishedCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MapListPublishedCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _project_id: Option, _page_token: Option, _max_results: Option, @@ -16592,9 +16588,9 @@ pub struct MapListPublishedCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MapListPublishedCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MapListPublishedCall<'a, C, A> {} -impl<'a, C, NC, A> MapListPublishedCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MapListPublishedCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16708,7 +16704,7 @@ impl<'a, C, NC, A> MapListPublishedCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The ID of a Maps Engine project, used to filter the response. To list all available projects with their IDs, send a Projects: list request. You can also find your project ID as the value of the DashboardPlace:cid URL parameter when signed in to mapsengine.google.com. - pub fn project_id(mut self, new_value: &str) -> MapListPublishedCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> MapListPublishedCall<'a, C, A> { self._project_id = Some(new_value.to_string()); self } @@ -16716,7 +16712,7 @@ impl<'a, C, NC, A> MapListPublishedCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The continuation token, used to page through large result sets. To get the next page of results, set this parameter to the value of nextPageToken from the previous response. - pub fn page_token(mut self, new_value: &str) -> MapListPublishedCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> MapListPublishedCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -16724,7 +16720,7 @@ impl<'a, C, NC, A> MapListPublishedCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The maximum number of items to include in a single response page. The maximum supported value is 100. - pub fn max_results(mut self, new_value: u32) -> MapListPublishedCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> MapListPublishedCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -16735,7 +16731,7 @@ impl<'a, C, NC, A> MapListPublishedCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapListPublishedCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapListPublishedCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16756,7 +16752,7 @@ impl<'a, C, NC, A> MapListPublishedCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MapListPublishedCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MapListPublishedCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16773,7 +16769,7 @@ impl<'a, C, NC, A> MapListPublishedCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MapListPublishedCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MapListPublishedCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16817,10 +16813,10 @@ impl<'a, C, NC, A> MapListPublishedCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct MapPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MapPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: Map, _id: String, _delegate: Option<&'a mut Delegate>, @@ -16828,9 +16824,9 @@ pub struct MapPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MapPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MapPatchCall<'a, C, A> {} -impl<'a, C, NC, A> MapPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MapPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16958,7 +16954,7 @@ impl<'a, C, NC, A> MapPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Map) -> MapPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Map) -> MapPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -16968,7 +16964,7 @@ impl<'a, C, NC, A> MapPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The ID of the map. - pub fn id(mut self, new_value: &str) -> MapPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> MapPatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -16979,7 +16975,7 @@ impl<'a, C, NC, A> MapPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17000,7 +16996,7 @@ impl<'a, C, NC, A> MapPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MapPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MapPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17017,7 +17013,7 @@ impl<'a, C, NC, A> MapPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MapPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MapPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17063,10 +17059,10 @@ impl<'a, C, NC, A> MapPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct MapPermissionBatchUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MapPermissionBatchUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: PermissionsBatchUpdateRequest, _id: String, _delegate: Option<&'a mut Delegate>, @@ -17074,9 +17070,9 @@ pub struct MapPermissionBatchUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MapPermissionBatchUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MapPermissionBatchUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> MapPermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MapPermissionBatchUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17215,7 +17211,7 @@ impl<'a, C, NC, A> MapPermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper::n /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PermissionsBatchUpdateRequest) -> MapPermissionBatchUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PermissionsBatchUpdateRequest) -> MapPermissionBatchUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -17225,7 +17221,7 @@ impl<'a, C, NC, A> MapPermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The ID of the asset to which permissions will be added. - pub fn id(mut self, new_value: &str) -> MapPermissionBatchUpdateCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> MapPermissionBatchUpdateCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -17236,7 +17232,7 @@ impl<'a, C, NC, A> MapPermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapPermissionBatchUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapPermissionBatchUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17257,7 +17253,7 @@ impl<'a, C, NC, A> MapPermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MapPermissionBatchUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MapPermissionBatchUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17274,7 +17270,7 @@ impl<'a, C, NC, A> MapPermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MapPermissionBatchUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MapPermissionBatchUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17312,19 +17308,19 @@ impl<'a, C, NC, A> MapPermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct MapDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MapDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MapDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MapDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> MapDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MapDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17445,7 +17441,7 @@ impl<'a, C, NC, A> MapDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the map. Only the map creator or project owner are permitted to delete. If the map is published the request will fail. Unpublish the map prior to deleting. - pub fn id(mut self, new_value: &str) -> MapDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> MapDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -17456,7 +17452,7 @@ impl<'a, C, NC, A> MapDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17477,7 +17473,7 @@ impl<'a, C, NC, A> MapDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MapDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MapDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17494,7 +17490,7 @@ impl<'a, C, NC, A> MapDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MapDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MapDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17532,19 +17528,19 @@ impl<'a, C, NC, A> MapDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct MapUnpublishCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MapUnpublishCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MapUnpublishCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MapUnpublishCall<'a, C, A> {} -impl<'a, C, NC, A> MapUnpublishCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MapUnpublishCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17676,7 +17672,7 @@ impl<'a, C, NC, A> MapUnpublishCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the map. - pub fn id(mut self, new_value: &str) -> MapUnpublishCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> MapUnpublishCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -17687,7 +17683,7 @@ impl<'a, C, NC, A> MapUnpublishCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapUnpublishCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapUnpublishCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17708,7 +17704,7 @@ impl<'a, C, NC, A> MapUnpublishCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MapUnpublishCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MapUnpublishCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17725,7 +17721,7 @@ impl<'a, C, NC, A> MapUnpublishCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MapUnpublishCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MapUnpublishCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17764,10 +17760,10 @@ impl<'a, C, NC, A> MapUnpublishCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct MapPublishCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MapPublishCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _force: Option, _delegate: Option<&'a mut Delegate>, @@ -17775,9 +17771,9 @@ pub struct MapPublishCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MapPublishCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MapPublishCall<'a, C, A> {} -impl<'a, C, NC, A> MapPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MapPublishCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17912,7 +17908,7 @@ impl<'a, C, NC, A> MapPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the map. - pub fn id(mut self, new_value: &str) -> MapPublishCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> MapPublishCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -17920,7 +17916,7 @@ impl<'a, C, NC, A> MapPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// If set to true, the API will allow publication of the map even if it's out of date. If false, the map must have a processingStatus of complete before publishing. - pub fn force(mut self, new_value: bool) -> MapPublishCall<'a, C, NC, A> { + pub fn force(mut self, new_value: bool) -> MapPublishCall<'a, C, A> { self._force = Some(new_value); self } @@ -17931,7 +17927,7 @@ impl<'a, C, NC, A> MapPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapPublishCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapPublishCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17952,7 +17948,7 @@ impl<'a, C, NC, A> MapPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MapPublishCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MapPublishCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17969,7 +17965,7 @@ impl<'a, C, NC, A> MapPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MapPublishCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MapPublishCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18007,19 +18003,19 @@ impl<'a, C, NC, A> MapPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct MapPermissionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MapPermissionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MapPermissionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MapPermissionListCall<'a, C, A> {} -impl<'a, C, NC, A> MapPermissionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MapPermissionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18151,7 +18147,7 @@ impl<'a, C, NC, A> MapPermissionListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the asset whose permissions will be listed. - pub fn id(mut self, new_value: &str) -> MapPermissionListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> MapPermissionListCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -18162,7 +18158,7 @@ impl<'a, C, NC, A> MapPermissionListCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapPermissionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapPermissionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18183,7 +18179,7 @@ impl<'a, C, NC, A> MapPermissionListCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MapPermissionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MapPermissionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18200,7 +18196,7 @@ impl<'a, C, NC, A> MapPermissionListCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MapPermissionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MapPermissionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18244,19 +18240,19 @@ impl<'a, C, NC, A> MapPermissionListCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct MapCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MapCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: Map, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MapCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MapCreateCall<'a, C, A> {} -impl<'a, C, NC, A> MapCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MapCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18370,7 +18366,7 @@ impl<'a, C, NC, A> MapCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Map) -> MapCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Map) -> MapCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -18381,7 +18377,7 @@ impl<'a, C, NC, A> MapCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18402,7 +18398,7 @@ impl<'a, C, NC, A> MapCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MapCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MapCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18419,7 +18415,7 @@ impl<'a, C, NC, A> MapCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MapCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MapCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18457,19 +18453,19 @@ impl<'a, C, NC, A> MapCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct MapGetPublishedCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MapGetPublishedCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MapGetPublishedCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MapGetPublishedCall<'a, C, A> {} -impl<'a, C, NC, A> MapGetPublishedCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MapGetPublishedCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18601,7 +18597,7 @@ impl<'a, C, NC, A> MapGetPublishedCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the map. - pub fn id(mut self, new_value: &str) -> MapGetPublishedCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> MapGetPublishedCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -18612,7 +18608,7 @@ impl<'a, C, NC, A> MapGetPublishedCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapGetPublishedCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapGetPublishedCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18633,7 +18629,7 @@ impl<'a, C, NC, A> MapGetPublishedCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MapGetPublishedCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MapGetPublishedCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18650,7 +18646,7 @@ impl<'a, C, NC, A> MapGetPublishedCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MapGetPublishedCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MapGetPublishedCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18689,10 +18685,10 @@ impl<'a, C, NC, A> MapGetPublishedCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct MapGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MapGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _version: Option, _delegate: Option<&'a mut Delegate>, @@ -18700,9 +18696,9 @@ pub struct MapGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MapGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MapGetCall<'a, C, A> {} -impl<'a, C, NC, A> MapGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MapGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18837,7 +18833,7 @@ impl<'a, C, NC, A> MapGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// we provide this method for API completeness. /// /// The ID of the map. - pub fn id(mut self, new_value: &str) -> MapGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> MapGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -18845,7 +18841,7 @@ impl<'a, C, NC, A> MapGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Deprecated: The version parameter indicates which version of the map should be returned. When version is set to published, the published version of the map will be returned. Please use the maps.getPublished endpoint instead. - pub fn version(mut self, new_value: &str) -> MapGetCall<'a, C, NC, A> { + pub fn version(mut self, new_value: &str) -> MapGetCall<'a, C, A> { self._version = Some(new_value.to_string()); self } @@ -18856,7 +18852,7 @@ impl<'a, C, NC, A> MapGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18877,7 +18873,7 @@ impl<'a, C, NC, A> MapGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MapGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MapGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18894,7 +18890,7 @@ impl<'a, C, NC, A> MapGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MapGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MapGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18938,10 +18934,10 @@ impl<'a, C, NC, A> MapGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// .doit(); /// # } /// ``` -pub struct MapPermissionBatchDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MapPermissionBatchDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: PermissionsBatchDeleteRequest, _id: String, _delegate: Option<&'a mut Delegate>, @@ -18949,9 +18945,9 @@ pub struct MapPermissionBatchDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MapPermissionBatchDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MapPermissionBatchDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> MapPermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MapPermissionBatchDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19090,7 +19086,7 @@ impl<'a, C, NC, A> MapPermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper::n /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PermissionsBatchDeleteRequest) -> MapPermissionBatchDeleteCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PermissionsBatchDeleteRequest) -> MapPermissionBatchDeleteCall<'a, C, A> { self._request = new_value.clone(); self } @@ -19100,7 +19096,7 @@ impl<'a, C, NC, A> MapPermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The ID of the asset from which permissions will be removed. - pub fn id(mut self, new_value: &str) -> MapPermissionBatchDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> MapPermissionBatchDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -19111,7 +19107,7 @@ impl<'a, C, NC, A> MapPermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapPermissionBatchDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MapPermissionBatchDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19132,7 +19128,7 @@ impl<'a, C, NC, A> MapPermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MapPermissionBatchDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MapPermissionBatchDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19149,7 +19145,7 @@ impl<'a, C, NC, A> MapPermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MapPermissionBatchDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MapPermissionBatchDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19193,19 +19189,19 @@ impl<'a, C, NC, A> MapPermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct RasterCollectionCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterCollectionCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: RasterCollection, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterCollectionCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterCollectionCreateCall<'a, C, A> {} -impl<'a, C, NC, A> RasterCollectionCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterCollectionCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19319,7 +19315,7 @@ impl<'a, C, NC, A> RasterCollectionCreateCall<'a, C, NC, A> where NC: hyper::net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &RasterCollection) -> RasterCollectionCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &RasterCollection) -> RasterCollectionCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -19330,7 +19326,7 @@ impl<'a, C, NC, A> RasterCollectionCreateCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19351,7 +19347,7 @@ impl<'a, C, NC, A> RasterCollectionCreateCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterCollectionCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterCollectionCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19368,7 +19364,7 @@ impl<'a, C, NC, A> RasterCollectionCreateCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterCollectionCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterCollectionCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19412,10 +19408,10 @@ impl<'a, C, NC, A> RasterCollectionCreateCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct RasterCollectionPermissionBatchDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterCollectionPermissionBatchDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: PermissionsBatchDeleteRequest, _id: String, _delegate: Option<&'a mut Delegate>, @@ -19423,9 +19419,9 @@ pub struct RasterCollectionPermissionBatchDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterCollectionPermissionBatchDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterCollectionPermissionBatchDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> RasterCollectionPermissionBatchDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterCollectionPermissionBatchDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19564,7 +19560,7 @@ impl<'a, C, NC, A> RasterCollectionPermissionBatchDeleteCall<'a, C, NC, A> where /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PermissionsBatchDeleteRequest) -> RasterCollectionPermissionBatchDeleteCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PermissionsBatchDeleteRequest) -> RasterCollectionPermissionBatchDeleteCall<'a, C, A> { self._request = new_value.clone(); self } @@ -19574,7 +19570,7 @@ impl<'a, C, NC, A> RasterCollectionPermissionBatchDeleteCall<'a, C, NC, A> where /// we provide this method for API completeness. /// /// The ID of the asset from which permissions will be removed. - pub fn id(mut self, new_value: &str) -> RasterCollectionPermissionBatchDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> RasterCollectionPermissionBatchDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -19585,7 +19581,7 @@ impl<'a, C, NC, A> RasterCollectionPermissionBatchDeleteCall<'a, C, NC, A> where /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionPermissionBatchDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionPermissionBatchDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19606,7 +19602,7 @@ impl<'a, C, NC, A> RasterCollectionPermissionBatchDeleteCall<'a, C, NC, A> where /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterCollectionPermissionBatchDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterCollectionPermissionBatchDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19623,7 +19619,7 @@ impl<'a, C, NC, A> RasterCollectionPermissionBatchDeleteCall<'a, C, NC, A> where /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterCollectionPermissionBatchDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterCollectionPermissionBatchDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19667,10 +19663,10 @@ impl<'a, C, NC, A> RasterCollectionPermissionBatchDeleteCall<'a, C, NC, A> where /// .doit(); /// # } /// ``` -pub struct RasterCollectionPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterCollectionPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: RasterCollection, _id: String, _delegate: Option<&'a mut Delegate>, @@ -19678,9 +19674,9 @@ pub struct RasterCollectionPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterCollectionPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterCollectionPatchCall<'a, C, A> {} -impl<'a, C, NC, A> RasterCollectionPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterCollectionPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19808,7 +19804,7 @@ impl<'a, C, NC, A> RasterCollectionPatchCall<'a, C, NC, A> where NC: hyper::net: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &RasterCollection) -> RasterCollectionPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &RasterCollection) -> RasterCollectionPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -19818,7 +19814,7 @@ impl<'a, C, NC, A> RasterCollectionPatchCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The ID of the raster collection. - pub fn id(mut self, new_value: &str) -> RasterCollectionPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> RasterCollectionPatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -19829,7 +19825,7 @@ impl<'a, C, NC, A> RasterCollectionPatchCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19850,7 +19846,7 @@ impl<'a, C, NC, A> RasterCollectionPatchCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterCollectionPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterCollectionPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19867,7 +19863,7 @@ impl<'a, C, NC, A> RasterCollectionPatchCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterCollectionPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterCollectionPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19905,19 +19901,19 @@ impl<'a, C, NC, A> RasterCollectionPatchCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct RasterCollectionCancelProcessingCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterCollectionCancelProcessingCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterCollectionCancelProcessingCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterCollectionCancelProcessingCall<'a, C, A> {} -impl<'a, C, NC, A> RasterCollectionCancelProcessingCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterCollectionCancelProcessingCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -20049,7 +20045,7 @@ impl<'a, C, NC, A> RasterCollectionCancelProcessingCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// The ID of the raster collection. - pub fn id(mut self, new_value: &str) -> RasterCollectionCancelProcessingCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> RasterCollectionCancelProcessingCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -20060,7 +20056,7 @@ impl<'a, C, NC, A> RasterCollectionCancelProcessingCall<'a, C, NC, A> where NC: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionCancelProcessingCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionCancelProcessingCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -20081,7 +20077,7 @@ impl<'a, C, NC, A> RasterCollectionCancelProcessingCall<'a, C, NC, A> where NC: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterCollectionCancelProcessingCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterCollectionCancelProcessingCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -20098,7 +20094,7 @@ impl<'a, C, NC, A> RasterCollectionCancelProcessingCall<'a, C, NC, A> where NC: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterCollectionCancelProcessingCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterCollectionCancelProcessingCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -20136,19 +20132,19 @@ impl<'a, C, NC, A> RasterCollectionCancelProcessingCall<'a, C, NC, A> where NC: /// .doit(); /// # } /// ``` -pub struct RasterCollectionProcesCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterCollectionProcesCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterCollectionProcesCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterCollectionProcesCall<'a, C, A> {} -impl<'a, C, NC, A> RasterCollectionProcesCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterCollectionProcesCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -20280,7 +20276,7 @@ impl<'a, C, NC, A> RasterCollectionProcesCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The ID of the raster collection. - pub fn id(mut self, new_value: &str) -> RasterCollectionProcesCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> RasterCollectionProcesCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -20291,7 +20287,7 @@ impl<'a, C, NC, A> RasterCollectionProcesCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionProcesCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionProcesCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -20312,7 +20308,7 @@ impl<'a, C, NC, A> RasterCollectionProcesCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterCollectionProcesCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterCollectionProcesCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -20329,7 +20325,7 @@ impl<'a, C, NC, A> RasterCollectionProcesCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterCollectionProcesCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterCollectionProcesCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -20375,10 +20371,10 @@ impl<'a, C, NC, A> RasterCollectionProcesCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct RasterCollectionPermissionBatchUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterCollectionPermissionBatchUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: PermissionsBatchUpdateRequest, _id: String, _delegate: Option<&'a mut Delegate>, @@ -20386,9 +20382,9 @@ pub struct RasterCollectionPermissionBatchUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterCollectionPermissionBatchUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterCollectionPermissionBatchUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> RasterCollectionPermissionBatchUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterCollectionPermissionBatchUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -20527,7 +20523,7 @@ impl<'a, C, NC, A> RasterCollectionPermissionBatchUpdateCall<'a, C, NC, A> where /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PermissionsBatchUpdateRequest) -> RasterCollectionPermissionBatchUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PermissionsBatchUpdateRequest) -> RasterCollectionPermissionBatchUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -20537,7 +20533,7 @@ impl<'a, C, NC, A> RasterCollectionPermissionBatchUpdateCall<'a, C, NC, A> where /// we provide this method for API completeness. /// /// The ID of the asset to which permissions will be added. - pub fn id(mut self, new_value: &str) -> RasterCollectionPermissionBatchUpdateCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> RasterCollectionPermissionBatchUpdateCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -20548,7 +20544,7 @@ impl<'a, C, NC, A> RasterCollectionPermissionBatchUpdateCall<'a, C, NC, A> where /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionPermissionBatchUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionPermissionBatchUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -20569,7 +20565,7 @@ impl<'a, C, NC, A> RasterCollectionPermissionBatchUpdateCall<'a, C, NC, A> where /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterCollectionPermissionBatchUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterCollectionPermissionBatchUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -20586,7 +20582,7 @@ impl<'a, C, NC, A> RasterCollectionPermissionBatchUpdateCall<'a, C, NC, A> where /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterCollectionPermissionBatchUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterCollectionPermissionBatchUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -20624,19 +20620,19 @@ impl<'a, C, NC, A> RasterCollectionPermissionBatchUpdateCall<'a, C, NC, A> where /// .doit(); /// # } /// ``` -pub struct RasterCollectionDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterCollectionDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterCollectionDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterCollectionDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> RasterCollectionDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterCollectionDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -20757,7 +20753,7 @@ impl<'a, C, NC, A> RasterCollectionDeleteCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The ID of the raster collection. Only the raster collection creator or project owner are permitted to delete. If the rastor collection is included in a layer, the request will fail. Remove the raster collection from all layers prior to deleting. - pub fn id(mut self, new_value: &str) -> RasterCollectionDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> RasterCollectionDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -20768,7 +20764,7 @@ impl<'a, C, NC, A> RasterCollectionDeleteCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -20789,7 +20785,7 @@ impl<'a, C, NC, A> RasterCollectionDeleteCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterCollectionDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterCollectionDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -20806,7 +20802,7 @@ impl<'a, C, NC, A> RasterCollectionDeleteCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterCollectionDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterCollectionDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -20846,10 +20842,10 @@ impl<'a, C, NC, A> RasterCollectionDeleteCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct RasterCollectionParentListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterCollectionParentListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _page_token: Option, _max_results: Option, @@ -20858,9 +20854,9 @@ pub struct RasterCollectionParentListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterCollectionParentListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterCollectionParentListCall<'a, C, A> {} -impl<'a, C, NC, A> RasterCollectionParentListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterCollectionParentListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -20998,7 +20994,7 @@ impl<'a, C, NC, A> RasterCollectionParentListCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The ID of the raster collection whose parents will be listed. - pub fn id(mut self, new_value: &str) -> RasterCollectionParentListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> RasterCollectionParentListCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -21006,7 +21002,7 @@ impl<'a, C, NC, A> RasterCollectionParentListCall<'a, C, NC, A> where NC: hyper: /// /// /// The continuation token, used to page through large result sets. To get the next page of results, set this parameter to the value of nextPageToken from the previous response. - pub fn page_token(mut self, new_value: &str) -> RasterCollectionParentListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> RasterCollectionParentListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -21014,7 +21010,7 @@ impl<'a, C, NC, A> RasterCollectionParentListCall<'a, C, NC, A> where NC: hyper: /// /// /// The maximum number of items to include in a single response page. The maximum supported value is 50. - pub fn max_results(mut self, new_value: u32) -> RasterCollectionParentListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> RasterCollectionParentListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -21025,7 +21021,7 @@ impl<'a, C, NC, A> RasterCollectionParentListCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionParentListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionParentListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -21046,7 +21042,7 @@ impl<'a, C, NC, A> RasterCollectionParentListCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterCollectionParentListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterCollectionParentListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -21063,7 +21059,7 @@ impl<'a, C, NC, A> RasterCollectionParentListCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterCollectionParentListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterCollectionParentListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -21114,10 +21110,10 @@ impl<'a, C, NC, A> RasterCollectionParentListCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct RasterCollectionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterCollectionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _tags: Option, _search: Option, _role: Option, @@ -21136,9 +21132,9 @@ pub struct RasterCollectionListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterCollectionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterCollectionListCall<'a, C, A> {} -impl<'a, C, NC, A> RasterCollectionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterCollectionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -21282,7 +21278,7 @@ impl<'a, C, NC, A> RasterCollectionListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// A comma separated list of tags. Returned assets will contain all the tags from the list. - pub fn tags(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, NC, A> { + pub fn tags(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, A> { self._tags = Some(new_value.to_string()); self } @@ -21290,7 +21286,7 @@ impl<'a, C, NC, A> RasterCollectionListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// An unstructured search string used to filter the set of results based on asset metadata. - pub fn search(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, NC, A> { + pub fn search(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, A> { self._search = Some(new_value.to_string()); self } @@ -21298,7 +21294,7 @@ impl<'a, C, NC, A> RasterCollectionListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// The role parameter indicates that the response should only contain assets where the current user has the specified level of access. - pub fn role(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, NC, A> { + pub fn role(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, A> { self._role = Some(new_value.to_string()); self } @@ -21306,14 +21302,14 @@ impl<'a, C, NC, A> RasterCollectionListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// The ID of a Maps Engine project, used to filter the response. To list all available projects with their IDs, send a Projects: list request. You can also find your project ID as the value of the DashboardPlace:cid URL parameter when signed in to mapsengine.google.com. - pub fn project_id(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, A> { self._project_id = Some(new_value.to_string()); self } /// Sets the *processing status* query property to the given value. /// /// - pub fn processing_status(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, NC, A> { + pub fn processing_status(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, A> { self._processing_status = Some(new_value.to_string()); self } @@ -21321,7 +21317,7 @@ impl<'a, C, NC, A> RasterCollectionListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// The continuation token, used to page through large result sets. To get the next page of results, set this parameter to the value of nextPageToken from the previous response. - pub fn page_token(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -21329,7 +21325,7 @@ impl<'a, C, NC, A> RasterCollectionListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been modified at or before this time. - pub fn modified_before(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, NC, A> { + pub fn modified_before(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, A> { self._modified_before = Some(new_value.to_string()); self } @@ -21337,7 +21333,7 @@ impl<'a, C, NC, A> RasterCollectionListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been modified at or after this time. - pub fn modified_after(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, NC, A> { + pub fn modified_after(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, A> { self._modified_after = Some(new_value.to_string()); self } @@ -21345,7 +21341,7 @@ impl<'a, C, NC, A> RasterCollectionListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// The maximum number of items to include in a single response page. The maximum supported value is 100. - pub fn max_results(mut self, new_value: u32) -> RasterCollectionListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> RasterCollectionListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -21353,7 +21349,7 @@ impl<'a, C, NC, A> RasterCollectionListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// An email address representing a user. Returned assets that have been created by the user associated with the provided email address. - pub fn creator_email(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, NC, A> { + pub fn creator_email(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, A> { self._creator_email = Some(new_value.to_string()); self } @@ -21361,7 +21357,7 @@ impl<'a, C, NC, A> RasterCollectionListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been created at or before this time. - pub fn created_before(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, NC, A> { + pub fn created_before(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, A> { self._created_before = Some(new_value.to_string()); self } @@ -21369,7 +21365,7 @@ impl<'a, C, NC, A> RasterCollectionListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been created at or after this time. - pub fn created_after(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, NC, A> { + pub fn created_after(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, A> { self._created_after = Some(new_value.to_string()); self } @@ -21377,7 +21373,7 @@ impl<'a, C, NC, A> RasterCollectionListCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// A bounding box, expressed as "west,south,east,north". If set, only assets which intersect this bounding box will be returned. - pub fn bbox(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, NC, A> { + pub fn bbox(mut self, new_value: &str) -> RasterCollectionListCall<'a, C, A> { self._bbox = Some(new_value.to_string()); self } @@ -21388,7 +21384,7 @@ impl<'a, C, NC, A> RasterCollectionListCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -21409,7 +21405,7 @@ impl<'a, C, NC, A> RasterCollectionListCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterCollectionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterCollectionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -21426,7 +21422,7 @@ impl<'a, C, NC, A> RasterCollectionListCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterCollectionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterCollectionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -21472,10 +21468,10 @@ impl<'a, C, NC, A> RasterCollectionListCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct RasterCollectionRasterBatchInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterCollectionRasterBatchInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: RasterCollectionsRastersBatchInsertRequest, _id: String, _delegate: Option<&'a mut Delegate>, @@ -21483,9 +21479,9 @@ pub struct RasterCollectionRasterBatchInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterCollectionRasterBatchInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterCollectionRasterBatchInsertCall<'a, C, A> {} -impl<'a, C, NC, A> RasterCollectionRasterBatchInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterCollectionRasterBatchInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -21624,7 +21620,7 @@ impl<'a, C, NC, A> RasterCollectionRasterBatchInsertCall<'a, C, NC, A> where NC: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &RasterCollectionsRastersBatchInsertRequest) -> RasterCollectionRasterBatchInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &RasterCollectionsRastersBatchInsertRequest) -> RasterCollectionRasterBatchInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -21634,7 +21630,7 @@ impl<'a, C, NC, A> RasterCollectionRasterBatchInsertCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// The ID of the raster collection to which these rasters belong. - pub fn id(mut self, new_value: &str) -> RasterCollectionRasterBatchInsertCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> RasterCollectionRasterBatchInsertCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -21645,7 +21641,7 @@ impl<'a, C, NC, A> RasterCollectionRasterBatchInsertCall<'a, C, NC, A> where NC: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionRasterBatchInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionRasterBatchInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -21666,7 +21662,7 @@ impl<'a, C, NC, A> RasterCollectionRasterBatchInsertCall<'a, C, NC, A> where NC: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterCollectionRasterBatchInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterCollectionRasterBatchInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -21683,7 +21679,7 @@ impl<'a, C, NC, A> RasterCollectionRasterBatchInsertCall<'a, C, NC, A> where NC: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterCollectionRasterBatchInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterCollectionRasterBatchInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -21729,10 +21725,10 @@ impl<'a, C, NC, A> RasterCollectionRasterBatchInsertCall<'a, C, NC, A> where NC: /// .doit(); /// # } /// ``` -pub struct RasterCollectionRasterBatchDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterCollectionRasterBatchDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: RasterCollectionsRasterBatchDeleteRequest, _id: String, _delegate: Option<&'a mut Delegate>, @@ -21740,9 +21736,9 @@ pub struct RasterCollectionRasterBatchDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterCollectionRasterBatchDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterCollectionRasterBatchDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> RasterCollectionRasterBatchDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterCollectionRasterBatchDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -21881,7 +21877,7 @@ impl<'a, C, NC, A> RasterCollectionRasterBatchDeleteCall<'a, C, NC, A> where NC: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &RasterCollectionsRasterBatchDeleteRequest) -> RasterCollectionRasterBatchDeleteCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &RasterCollectionsRasterBatchDeleteRequest) -> RasterCollectionRasterBatchDeleteCall<'a, C, A> { self._request = new_value.clone(); self } @@ -21891,7 +21887,7 @@ impl<'a, C, NC, A> RasterCollectionRasterBatchDeleteCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// The ID of the raster collection to which these rasters belong. - pub fn id(mut self, new_value: &str) -> RasterCollectionRasterBatchDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> RasterCollectionRasterBatchDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -21902,7 +21898,7 @@ impl<'a, C, NC, A> RasterCollectionRasterBatchDeleteCall<'a, C, NC, A> where NC: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionRasterBatchDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionRasterBatchDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -21923,7 +21919,7 @@ impl<'a, C, NC, A> RasterCollectionRasterBatchDeleteCall<'a, C, NC, A> where NC: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterCollectionRasterBatchDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterCollectionRasterBatchDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -21940,7 +21936,7 @@ impl<'a, C, NC, A> RasterCollectionRasterBatchDeleteCall<'a, C, NC, A> where NC: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterCollectionRasterBatchDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterCollectionRasterBatchDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -21978,19 +21974,19 @@ impl<'a, C, NC, A> RasterCollectionRasterBatchDeleteCall<'a, C, NC, A> where NC: /// .doit(); /// # } /// ``` -pub struct RasterCollectionPermissionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterCollectionPermissionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterCollectionPermissionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterCollectionPermissionListCall<'a, C, A> {} -impl<'a, C, NC, A> RasterCollectionPermissionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterCollectionPermissionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -22122,7 +22118,7 @@ impl<'a, C, NC, A> RasterCollectionPermissionListCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// The ID of the asset whose permissions will be listed. - pub fn id(mut self, new_value: &str) -> RasterCollectionPermissionListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> RasterCollectionPermissionListCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -22133,7 +22129,7 @@ impl<'a, C, NC, A> RasterCollectionPermissionListCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionPermissionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionPermissionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -22154,7 +22150,7 @@ impl<'a, C, NC, A> RasterCollectionPermissionListCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterCollectionPermissionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterCollectionPermissionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -22171,7 +22167,7 @@ impl<'a, C, NC, A> RasterCollectionPermissionListCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterCollectionPermissionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterCollectionPermissionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -22209,19 +22205,19 @@ impl<'a, C, NC, A> RasterCollectionPermissionListCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct RasterCollectionGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterCollectionGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterCollectionGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterCollectionGetCall<'a, C, A> {} -impl<'a, C, NC, A> RasterCollectionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterCollectionGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -22353,7 +22349,7 @@ impl<'a, C, NC, A> RasterCollectionGetCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The ID of the raster collection. - pub fn id(mut self, new_value: &str) -> RasterCollectionGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> RasterCollectionGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -22364,7 +22360,7 @@ impl<'a, C, NC, A> RasterCollectionGetCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -22385,7 +22381,7 @@ impl<'a, C, NC, A> RasterCollectionGetCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterCollectionGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterCollectionGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -22402,7 +22398,7 @@ impl<'a, C, NC, A> RasterCollectionGetCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterCollectionGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterCollectionGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -22451,10 +22447,10 @@ impl<'a, C, NC, A> RasterCollectionGetCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct RasterCollectionRasterListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RasterCollectionRasterListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _id: String, _tags: Option, _search: Option, @@ -22472,9 +22468,9 @@ pub struct RasterCollectionRasterListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RasterCollectionRasterListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RasterCollectionRasterListCall<'a, C, A> {} -impl<'a, C, NC, A> RasterCollectionRasterListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RasterCollectionRasterListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -22639,7 +22635,7 @@ impl<'a, C, NC, A> RasterCollectionRasterListCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The ID of the raster collection to which these rasters belong. - pub fn id(mut self, new_value: &str) -> RasterCollectionRasterListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> RasterCollectionRasterListCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -22647,7 +22643,7 @@ impl<'a, C, NC, A> RasterCollectionRasterListCall<'a, C, NC, A> where NC: hyper: /// /// /// A comma separated list of tags. Returned assets will contain all the tags from the list. - pub fn tags(mut self, new_value: &str) -> RasterCollectionRasterListCall<'a, C, NC, A> { + pub fn tags(mut self, new_value: &str) -> RasterCollectionRasterListCall<'a, C, A> { self._tags = Some(new_value.to_string()); self } @@ -22655,7 +22651,7 @@ impl<'a, C, NC, A> RasterCollectionRasterListCall<'a, C, NC, A> where NC: hyper: /// /// /// An unstructured search string used to filter the set of results based on asset metadata. - pub fn search(mut self, new_value: &str) -> RasterCollectionRasterListCall<'a, C, NC, A> { + pub fn search(mut self, new_value: &str) -> RasterCollectionRasterListCall<'a, C, A> { self._search = Some(new_value.to_string()); self } @@ -22663,7 +22659,7 @@ impl<'a, C, NC, A> RasterCollectionRasterListCall<'a, C, NC, A> where NC: hyper: /// /// /// The role parameter indicates that the response should only contain assets where the current user has the specified level of access. - pub fn role(mut self, new_value: &str) -> RasterCollectionRasterListCall<'a, C, NC, A> { + pub fn role(mut self, new_value: &str) -> RasterCollectionRasterListCall<'a, C, A> { self._role = Some(new_value.to_string()); self } @@ -22671,7 +22667,7 @@ impl<'a, C, NC, A> RasterCollectionRasterListCall<'a, C, NC, A> where NC: hyper: /// /// /// The continuation token, used to page through large result sets. To get the next page of results, set this parameter to the value of nextPageToken from the previous response. - pub fn page_token(mut self, new_value: &str) -> RasterCollectionRasterListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> RasterCollectionRasterListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -22679,7 +22675,7 @@ impl<'a, C, NC, A> RasterCollectionRasterListCall<'a, C, NC, A> where NC: hyper: /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been modified at or before this time. - pub fn modified_before(mut self, new_value: &str) -> RasterCollectionRasterListCall<'a, C, NC, A> { + pub fn modified_before(mut self, new_value: &str) -> RasterCollectionRasterListCall<'a, C, A> { self._modified_before = Some(new_value.to_string()); self } @@ -22687,7 +22683,7 @@ impl<'a, C, NC, A> RasterCollectionRasterListCall<'a, C, NC, A> where NC: hyper: /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been modified at or after this time. - pub fn modified_after(mut self, new_value: &str) -> RasterCollectionRasterListCall<'a, C, NC, A> { + pub fn modified_after(mut self, new_value: &str) -> RasterCollectionRasterListCall<'a, C, A> { self._modified_after = Some(new_value.to_string()); self } @@ -22695,7 +22691,7 @@ impl<'a, C, NC, A> RasterCollectionRasterListCall<'a, C, NC, A> where NC: hyper: /// /// /// The maximum number of items to include in a single response page. The maximum supported value is 100. - pub fn max_results(mut self, new_value: u32) -> RasterCollectionRasterListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> RasterCollectionRasterListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -22703,7 +22699,7 @@ impl<'a, C, NC, A> RasterCollectionRasterListCall<'a, C, NC, A> where NC: hyper: /// /// /// An email address representing a user. Returned assets that have been created by the user associated with the provided email address. - pub fn creator_email(mut self, new_value: &str) -> RasterCollectionRasterListCall<'a, C, NC, A> { + pub fn creator_email(mut self, new_value: &str) -> RasterCollectionRasterListCall<'a, C, A> { self._creator_email = Some(new_value.to_string()); self } @@ -22711,7 +22707,7 @@ impl<'a, C, NC, A> RasterCollectionRasterListCall<'a, C, NC, A> where NC: hyper: /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been created at or before this time. - pub fn created_before(mut self, new_value: &str) -> RasterCollectionRasterListCall<'a, C, NC, A> { + pub fn created_before(mut self, new_value: &str) -> RasterCollectionRasterListCall<'a, C, A> { self._created_before = Some(new_value.to_string()); self } @@ -22719,7 +22715,7 @@ impl<'a, C, NC, A> RasterCollectionRasterListCall<'a, C, NC, A> where NC: hyper: /// /// /// An RFC 3339 formatted date-time value (e.g. 1970-01-01T00:00:00Z). Returned assets will have been created at or after this time. - pub fn created_after(mut self, new_value: &str) -> RasterCollectionRasterListCall<'a, C, NC, A> { + pub fn created_after(mut self, new_value: &str) -> RasterCollectionRasterListCall<'a, C, A> { self._created_after = Some(new_value.to_string()); self } @@ -22727,7 +22723,7 @@ impl<'a, C, NC, A> RasterCollectionRasterListCall<'a, C, NC, A> where NC: hyper: /// /// /// A bounding box, expressed as "west,south,east,north". If set, only assets which intersect this bounding box will be returned. - pub fn bbox(mut self, new_value: &str) -> RasterCollectionRasterListCall<'a, C, NC, A> { + pub fn bbox(mut self, new_value: &str) -> RasterCollectionRasterListCall<'a, C, A> { self._bbox = Some(new_value.to_string()); self } @@ -22738,7 +22734,7 @@ impl<'a, C, NC, A> RasterCollectionRasterListCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionRasterListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RasterCollectionRasterListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -22759,7 +22755,7 @@ impl<'a, C, NC, A> RasterCollectionRasterListCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RasterCollectionRasterListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RasterCollectionRasterListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -22776,7 +22772,7 @@ impl<'a, C, NC, A> RasterCollectionRasterListCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RasterCollectionRasterListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RasterCollectionRasterListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -22819,10 +22815,10 @@ impl<'a, C, NC, A> RasterCollectionRasterListCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct ProjectIconGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectIconGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _project_id: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -22830,9 +22826,9 @@ pub struct ProjectIconGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectIconGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectIconGetCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectIconGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectIconGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -22981,7 +22977,7 @@ impl<'a, C, NC, A> ProjectIconGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the project. - pub fn project_id(mut self, new_value: &str) -> ProjectIconGetCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> ProjectIconGetCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -22991,7 +22987,7 @@ impl<'a, C, NC, A> ProjectIconGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the icon. - pub fn id(mut self, new_value: &str) -> ProjectIconGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> ProjectIconGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -23002,7 +22998,7 @@ impl<'a, C, NC, A> ProjectIconGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectIconGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectIconGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -23023,7 +23019,7 @@ impl<'a, C, NC, A> ProjectIconGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectIconGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectIconGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -23040,7 +23036,7 @@ impl<'a, C, NC, A> ProjectIconGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectIconGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectIconGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -23085,10 +23081,10 @@ impl<'a, C, NC, A> ProjectIconGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// .upload(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct ProjectIconCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectIconCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _request: Icon, _project_id: String, _delegate: Option<&'a mut Delegate>, @@ -23096,9 +23092,9 @@ pub struct ProjectIconCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectIconCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectIconCreateCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectIconCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectIconCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -23351,7 +23347,7 @@ impl<'a, C, NC, A> ProjectIconCreateCall<'a, C, NC, A> where NC: hyper::net::Net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Icon) -> ProjectIconCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Icon) -> ProjectIconCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -23361,7 +23357,7 @@ impl<'a, C, NC, A> ProjectIconCreateCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The ID of the project. - pub fn project_id(mut self, new_value: &str) -> ProjectIconCreateCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> ProjectIconCreateCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -23372,7 +23368,7 @@ impl<'a, C, NC, A> ProjectIconCreateCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectIconCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectIconCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -23393,7 +23389,7 @@ impl<'a, C, NC, A> ProjectIconCreateCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectIconCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectIconCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -23410,7 +23406,7 @@ impl<'a, C, NC, A> ProjectIconCreateCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectIconCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectIconCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -23448,18 +23444,18 @@ impl<'a, C, NC, A> ProjectIconCreateCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct ProjectListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectListCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -23567,7 +23563,7 @@ impl<'a, C, NC, A> ProjectListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -23588,7 +23584,7 @@ impl<'a, C, NC, A> ProjectListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -23605,7 +23601,7 @@ impl<'a, C, NC, A> ProjectListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -23645,10 +23641,10 @@ impl<'a, C, NC, A> ProjectListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct ProjectIconListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectIconListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a MapsEngine, + hub: &'a MapsEngine, _project_id: String, _page_token: Option, _max_results: Option, @@ -23657,9 +23653,9 @@ pub struct ProjectIconListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectIconListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectIconListCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectIconListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectIconListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -23797,7 +23793,7 @@ impl<'a, C, NC, A> ProjectIconListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the project. - pub fn project_id(mut self, new_value: &str) -> ProjectIconListCall<'a, C, NC, A> { + pub fn project_id(mut self, new_value: &str) -> ProjectIconListCall<'a, C, A> { self._project_id = new_value.to_string(); self } @@ -23805,7 +23801,7 @@ impl<'a, C, NC, A> ProjectIconListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The continuation token, used to page through large result sets. To get the next page of results, set this parameter to the value of nextPageToken from the previous response. - pub fn page_token(mut self, new_value: &str) -> ProjectIconListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ProjectIconListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -23813,7 +23809,7 @@ impl<'a, C, NC, A> ProjectIconListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The maximum number of items to include in a single response page. The maximum supported value is 50. - pub fn max_results(mut self, new_value: u32) -> ProjectIconListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> ProjectIconListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -23824,7 +23820,7 @@ impl<'a, C, NC, A> ProjectIconListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectIconListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectIconListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -23845,7 +23841,7 @@ impl<'a, C, NC, A> ProjectIconListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectIconListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectIconListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -23862,7 +23858,7 @@ impl<'a, C, NC, A> ProjectIconListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectIconListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectIconListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/mirror1/Cargo.toml b/gen/mirror1/Cargo.toml index f8ee20b3fc5..4f27c3f43a0 100644 --- a/gen/mirror1/Cargo.toml +++ b/gen/mirror1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-mirror1" -version = "0.1.4+20150220" +version = "0.1.5+20150220" authors = ["Sebastian Thiel "] description = "A complete library to interact with mirror (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/mirror1" homepage = "https://developers.google.com/glass" -documentation = "http://byron.github.io/google-apis-rs/google-mirror1" +documentation = "http://byron.github.io/google-apis-rs/google_mirror1" license = "MIT" keywords = ["mirror", "google", "protocol", "web", "api"] diff --git a/gen/mirror1/README.md b/gen/mirror1/README.md index 60dc897605a..4912b169c12 100644 --- a/gen/mirror1/README.md +++ b/gen/mirror1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-mirror1` library allows access to all features of the *Google mirror* service. -This documentation was generated from *mirror* crate version *0.1.4+20150220*, where *20150220* is the exact revision of the *mirror:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *mirror* crate version *0.1.5+20150220*, where *20150220* is the exact revision of the *mirror:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *mirror* *v1* API can be found at the [official documentation site](https://developers.google.com/glass). diff --git a/gen/mirror1/src/cmn.rs b/gen/mirror1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/mirror1/src/cmn.rs +++ b/gen/mirror1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/mirror1/src/lib.rs b/gen/mirror1/src/lib.rs index 26c2c6f5ee2..8191685b251 100644 --- a/gen/mirror1/src/lib.rs +++ b/gen/mirror1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *mirror* crate version *0.1.4+20150220*, where *20150220* is the exact revision of the *mirror:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *mirror* crate version *0.1.5+20150220*, where *20150220* is the exact revision of the *mirror:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *mirror* *v1* API can be found at the //! [official documentation site](https://developers.google.com/glass). @@ -219,7 +219,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -320,49 +319,46 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Mirror { +pub struct Mirror { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Mirror {} +impl<'a, C, A> Hub for Mirror {} -impl<'a, C, NC, A> Mirror - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Mirror + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Mirror { + pub fn new(client: C, authenticator: A) -> Mirror { Mirror { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn accounts(&'a self) -> AccountMethods<'a, C, NC, A> { + pub fn accounts(&'a self) -> AccountMethods<'a, C, A> { AccountMethods { hub: &self } } - pub fn contacts(&'a self) -> ContactMethods<'a, C, NC, A> { + pub fn contacts(&'a self) -> ContactMethods<'a, C, A> { ContactMethods { hub: &self } } - pub fn locations(&'a self) -> LocationMethods<'a, C, NC, A> { + pub fn locations(&'a self) -> LocationMethods<'a, C, A> { LocationMethods { hub: &self } } - pub fn settings(&'a self) -> SettingMethods<'a, C, NC, A> { + pub fn settings(&'a self) -> SettingMethods<'a, C, A> { SettingMethods { hub: &self } } - pub fn subscriptions(&'a self) -> SubscriptionMethods<'a, C, NC, A> { + pub fn subscriptions(&'a self) -> SubscriptionMethods<'a, C, A> { SubscriptionMethods { hub: &self } } - pub fn timeline(&'a self) -> TimelineMethods<'a, C, NC, A> { + pub fn timeline(&'a self) -> TimelineMethods<'a, C, A> { TimelineMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -1034,15 +1030,15 @@ impl ResponseResult for Subscription {} /// let rb = hub.subscriptions(); /// # } /// ``` -pub struct SubscriptionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubscriptionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, } -impl<'a, C, NC, A> MethodsBuilder for SubscriptionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for SubscriptionMethods<'a, C, A> {} -impl<'a, C, NC, A> SubscriptionMethods<'a, C, NC, A> { +impl<'a, C, A> SubscriptionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1051,7 +1047,7 @@ impl<'a, C, NC, A> SubscriptionMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &Subscription) -> SubscriptionInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Subscription) -> SubscriptionInsertCall<'a, C, A> { SubscriptionInsertCall { hub: self.hub, _request: request.clone(), @@ -1068,7 +1064,7 @@ impl<'a, C, NC, A> SubscriptionMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the subscription. - pub fn delete(&self, id: &str) -> SubscriptionDeleteCall<'a, C, NC, A> { + pub fn delete(&self, id: &str) -> SubscriptionDeleteCall<'a, C, A> { SubscriptionDeleteCall { hub: self.hub, _id: id.to_string(), @@ -1086,7 +1082,7 @@ impl<'a, C, NC, A> SubscriptionMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the subscription. - pub fn update(&self, request: &Subscription, id: &str) -> SubscriptionUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Subscription, id: &str) -> SubscriptionUpdateCall<'a, C, A> { SubscriptionUpdateCall { hub: self.hub, _request: request.clone(), @@ -1100,7 +1096,7 @@ impl<'a, C, NC, A> SubscriptionMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Retrieves a list of subscriptions for the authenticated user and service. - pub fn list(&self) -> SubscriptionListCall<'a, C, NC, A> { + pub fn list(&self) -> SubscriptionListCall<'a, C, A> { SubscriptionListCall { hub: self.hub, _delegate: Default::default(), @@ -1140,15 +1136,15 @@ impl<'a, C, NC, A> SubscriptionMethods<'a, C, NC, A> { /// let rb = hub.timeline(); /// # } /// ``` -pub struct TimelineMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TimelineMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, } -impl<'a, C, NC, A> MethodsBuilder for TimelineMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TimelineMethods<'a, C, A> {} -impl<'a, C, NC, A> TimelineMethods<'a, C, NC, A> { +impl<'a, C, A> TimelineMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1157,7 +1153,7 @@ impl<'a, C, NC, A> TimelineMethods<'a, C, NC, A> { /// # Arguments /// /// * `itemId` - The ID of the timeline item whose attachments should be listed. - pub fn attachments_list(&self, item_id: &str) -> TimelineAttachmentListCall<'a, C, NC, A> { + pub fn attachments_list(&self, item_id: &str) -> TimelineAttachmentListCall<'a, C, A> { TimelineAttachmentListCall { hub: self.hub, _item_id: item_id.to_string(), @@ -1174,7 +1170,7 @@ impl<'a, C, NC, A> TimelineMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &TimelineItem) -> TimelineInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &TimelineItem) -> TimelineInsertCall<'a, C, A> { TimelineInsertCall { hub: self.hub, _request: request.clone(), @@ -1192,7 +1188,7 @@ impl<'a, C, NC, A> TimelineMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the timeline item. - pub fn patch(&self, request: &TimelineItem, id: &str) -> TimelinePatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &TimelineItem, id: &str) -> TimelinePatchCall<'a, C, A> { TimelinePatchCall { hub: self.hub, _request: request.clone(), @@ -1206,7 +1202,7 @@ impl<'a, C, NC, A> TimelineMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Retrieves a list of timeline items for the authenticated user. - pub fn list(&self) -> TimelineListCall<'a, C, NC, A> { + pub fn list(&self) -> TimelineListCall<'a, C, A> { TimelineListCall { hub: self.hub, _source_item_id: Default::default(), @@ -1229,7 +1225,7 @@ impl<'a, C, NC, A> TimelineMethods<'a, C, NC, A> { /// # Arguments /// /// * `itemId` - The ID of the timeline item the attachment belongs to. - pub fn attachments_insert(&self, item_id: &str) -> TimelineAttachmentInsertCall<'a, C, NC, A> { + pub fn attachments_insert(&self, item_id: &str) -> TimelineAttachmentInsertCall<'a, C, A> { TimelineAttachmentInsertCall { hub: self.hub, _item_id: item_id.to_string(), @@ -1247,7 +1243,7 @@ impl<'a, C, NC, A> TimelineMethods<'a, C, NC, A> { /// /// * `itemId` - The ID of the timeline item the attachment belongs to. /// * `attachmentId` - The ID of the attachment. - pub fn attachments_delete(&self, item_id: &str, attachment_id: &str) -> TimelineAttachmentDeleteCall<'a, C, NC, A> { + pub fn attachments_delete(&self, item_id: &str, attachment_id: &str) -> TimelineAttachmentDeleteCall<'a, C, A> { TimelineAttachmentDeleteCall { hub: self.hub, _item_id: item_id.to_string(), @@ -1265,7 +1261,7 @@ impl<'a, C, NC, A> TimelineMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the timeline item. - pub fn delete(&self, id: &str) -> TimelineDeleteCall<'a, C, NC, A> { + pub fn delete(&self, id: &str) -> TimelineDeleteCall<'a, C, A> { TimelineDeleteCall { hub: self.hub, _id: id.to_string(), @@ -1283,7 +1279,7 @@ impl<'a, C, NC, A> TimelineMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the timeline item. - pub fn update(&self, request: &TimelineItem, id: &str) -> TimelineUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &TimelineItem, id: &str) -> TimelineUpdateCall<'a, C, A> { TimelineUpdateCall { hub: self.hub, _request: request.clone(), @@ -1302,7 +1298,7 @@ impl<'a, C, NC, A> TimelineMethods<'a, C, NC, A> { /// /// * `itemId` - The ID of the timeline item the attachment belongs to. /// * `attachmentId` - The ID of the attachment. - pub fn attachments_get(&self, item_id: &str, attachment_id: &str) -> TimelineAttachmentGetCall<'a, C, NC, A> { + pub fn attachments_get(&self, item_id: &str, attachment_id: &str) -> TimelineAttachmentGetCall<'a, C, A> { TimelineAttachmentGetCall { hub: self.hub, _item_id: item_id.to_string(), @@ -1320,7 +1316,7 @@ impl<'a, C, NC, A> TimelineMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the timeline item. - pub fn get(&self, id: &str) -> TimelineGetCall<'a, C, NC, A> { + pub fn get(&self, id: &str) -> TimelineGetCall<'a, C, A> { TimelineGetCall { hub: self.hub, _id: id.to_string(), @@ -1361,15 +1357,15 @@ impl<'a, C, NC, A> TimelineMethods<'a, C, NC, A> { /// let rb = hub.settings(); /// # } /// ``` -pub struct SettingMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SettingMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, } -impl<'a, C, NC, A> MethodsBuilder for SettingMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for SettingMethods<'a, C, A> {} -impl<'a, C, NC, A> SettingMethods<'a, C, NC, A> { +impl<'a, C, A> SettingMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1380,7 +1376,7 @@ impl<'a, C, NC, A> SettingMethods<'a, C, NC, A> { /// * `id` - The ID of the setting. The following IDs are valid: /// - locale - The key to the user’s language/locale (BCP 47 identifier) that Glassware should use to render localized content. /// - timezone - The key to the user’s current time zone region as defined in the tz database. Example: America/Los_Angeles. - pub fn get(&self, id: &str) -> SettingGetCall<'a, C, NC, A> { + pub fn get(&self, id: &str) -> SettingGetCall<'a, C, A> { SettingGetCall { hub: self.hub, _id: id.to_string(), @@ -1421,15 +1417,15 @@ impl<'a, C, NC, A> SettingMethods<'a, C, NC, A> { /// let rb = hub.locations(); /// # } /// ``` -pub struct LocationMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LocationMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, } -impl<'a, C, NC, A> MethodsBuilder for LocationMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for LocationMethods<'a, C, A> {} -impl<'a, C, NC, A> LocationMethods<'a, C, NC, A> { +impl<'a, C, A> LocationMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1438,7 +1434,7 @@ impl<'a, C, NC, A> LocationMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the location or latest for the last known location. - pub fn get(&self, id: &str) -> LocationGetCall<'a, C, NC, A> { + pub fn get(&self, id: &str) -> LocationGetCall<'a, C, A> { LocationGetCall { hub: self.hub, _id: id.to_string(), @@ -1451,7 +1447,7 @@ impl<'a, C, NC, A> LocationMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Retrieves a list of locations for the user. - pub fn list(&self) -> LocationListCall<'a, C, NC, A> { + pub fn list(&self) -> LocationListCall<'a, C, A> { LocationListCall { hub: self.hub, _delegate: Default::default(), @@ -1491,15 +1487,15 @@ impl<'a, C, NC, A> LocationMethods<'a, C, NC, A> { /// let rb = hub.accounts(); /// # } /// ``` -pub struct AccountMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, } -impl<'a, C, NC, A> MethodsBuilder for AccountMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AccountMethods<'a, C, A> {} -impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { +impl<'a, C, A> AccountMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1511,7 +1507,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `userToken` - The ID for the user. /// * `accountType` - Account type to be passed to Android Account Manager. /// * `accountName` - The name of the account to be passed to the Android Account Manager. - pub fn insert(&self, request: &Account, user_token: &str, account_type: &str, account_name: &str) -> AccountInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Account, user_token: &str, account_type: &str, account_name: &str) -> AccountInsertCall<'a, C, A> { AccountInsertCall { hub: self.hub, _request: request.clone(), @@ -1555,15 +1551,15 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// let rb = hub.contacts(); /// # } /// ``` -pub struct ContactMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ContactMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, } -impl<'a, C, NC, A> MethodsBuilder for ContactMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ContactMethods<'a, C, A> {} -impl<'a, C, NC, A> ContactMethods<'a, C, NC, A> { +impl<'a, C, A> ContactMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1572,7 +1568,7 @@ impl<'a, C, NC, A> ContactMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the contact. - pub fn get(&self, id: &str) -> ContactGetCall<'a, C, NC, A> { + pub fn get(&self, id: &str) -> ContactGetCall<'a, C, A> { ContactGetCall { hub: self.hub, _id: id.to_string(), @@ -1589,7 +1585,7 @@ impl<'a, C, NC, A> ContactMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the contact. - pub fn delete(&self, id: &str) -> ContactDeleteCall<'a, C, NC, A> { + pub fn delete(&self, id: &str) -> ContactDeleteCall<'a, C, A> { ContactDeleteCall { hub: self.hub, _id: id.to_string(), @@ -1606,7 +1602,7 @@ impl<'a, C, NC, A> ContactMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &Contact) -> ContactInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Contact) -> ContactInsertCall<'a, C, A> { ContactInsertCall { hub: self.hub, _request: request.clone(), @@ -1624,7 +1620,7 @@ impl<'a, C, NC, A> ContactMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the contact. - pub fn patch(&self, request: &Contact, id: &str) -> ContactPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Contact, id: &str) -> ContactPatchCall<'a, C, A> { ContactPatchCall { hub: self.hub, _request: request.clone(), @@ -1638,7 +1634,7 @@ impl<'a, C, NC, A> ContactMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Retrieves a list of contacts for the authenticated user. - pub fn list(&self) -> ContactListCall<'a, C, NC, A> { + pub fn list(&self) -> ContactListCall<'a, C, A> { ContactListCall { hub: self.hub, _delegate: Default::default(), @@ -1655,7 +1651,7 @@ impl<'a, C, NC, A> ContactMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The ID of the contact. - pub fn update(&self, request: &Contact, id: &str) -> ContactUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Contact, id: &str) -> ContactUpdateCall<'a, C, A> { ContactUpdateCall { hub: self.hub, _request: request.clone(), @@ -1711,19 +1707,19 @@ impl<'a, C, NC, A> ContactMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct SubscriptionInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubscriptionInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _request: Subscription, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SubscriptionInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SubscriptionInsertCall<'a, C, A> {} -impl<'a, C, NC, A> SubscriptionInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SubscriptionInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1837,7 +1833,7 @@ impl<'a, C, NC, A> SubscriptionInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Subscription) -> SubscriptionInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Subscription) -> SubscriptionInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1848,7 +1844,7 @@ impl<'a, C, NC, A> SubscriptionInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1869,7 +1865,7 @@ impl<'a, C, NC, A> SubscriptionInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SubscriptionInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SubscriptionInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1886,7 +1882,7 @@ impl<'a, C, NC, A> SubscriptionInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SubscriptionInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SubscriptionInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1924,19 +1920,19 @@ impl<'a, C, NC, A> SubscriptionInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct SubscriptionDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubscriptionDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SubscriptionDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SubscriptionDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> SubscriptionDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SubscriptionDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2057,7 +2053,7 @@ impl<'a, C, NC, A> SubscriptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The ID of the subscription. - pub fn id(mut self, new_value: &str) -> SubscriptionDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> SubscriptionDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -2068,7 +2064,7 @@ impl<'a, C, NC, A> SubscriptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2089,7 +2085,7 @@ impl<'a, C, NC, A> SubscriptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SubscriptionDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SubscriptionDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2106,7 +2102,7 @@ impl<'a, C, NC, A> SubscriptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SubscriptionDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SubscriptionDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2150,10 +2146,10 @@ impl<'a, C, NC, A> SubscriptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct SubscriptionUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubscriptionUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _request: Subscription, _id: String, _delegate: Option<&'a mut Delegate>, @@ -2161,9 +2157,9 @@ pub struct SubscriptionUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SubscriptionUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SubscriptionUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> SubscriptionUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SubscriptionUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2302,7 +2298,7 @@ impl<'a, C, NC, A> SubscriptionUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Subscription) -> SubscriptionUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Subscription) -> SubscriptionUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2312,7 +2308,7 @@ impl<'a, C, NC, A> SubscriptionUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The ID of the subscription. - pub fn id(mut self, new_value: &str) -> SubscriptionUpdateCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> SubscriptionUpdateCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -2323,7 +2319,7 @@ impl<'a, C, NC, A> SubscriptionUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2344,7 +2340,7 @@ impl<'a, C, NC, A> SubscriptionUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SubscriptionUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SubscriptionUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2361,7 +2357,7 @@ impl<'a, C, NC, A> SubscriptionUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SubscriptionUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SubscriptionUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2399,18 +2395,18 @@ impl<'a, C, NC, A> SubscriptionUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct SubscriptionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubscriptionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SubscriptionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SubscriptionListCall<'a, C, A> {} -impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SubscriptionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2518,7 +2514,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2539,7 +2535,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SubscriptionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SubscriptionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2556,7 +2552,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SubscriptionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SubscriptionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2594,19 +2590,19 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct TimelineAttachmentListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TimelineAttachmentListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _item_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TimelineAttachmentListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TimelineAttachmentListCall<'a, C, A> {} -impl<'a, C, NC, A> TimelineAttachmentListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TimelineAttachmentListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2738,7 +2734,7 @@ impl<'a, C, NC, A> TimelineAttachmentListCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The ID of the timeline item whose attachments should be listed. - pub fn item_id(mut self, new_value: &str) -> TimelineAttachmentListCall<'a, C, NC, A> { + pub fn item_id(mut self, new_value: &str) -> TimelineAttachmentListCall<'a, C, A> { self._item_id = new_value.to_string(); self } @@ -2749,7 +2745,7 @@ impl<'a, C, NC, A> TimelineAttachmentListCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimelineAttachmentListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimelineAttachmentListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2770,7 +2766,7 @@ impl<'a, C, NC, A> TimelineAttachmentListCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TimelineAttachmentListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TimelineAttachmentListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2787,7 +2783,7 @@ impl<'a, C, NC, A> TimelineAttachmentListCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TimelineAttachmentListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TimelineAttachmentListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2832,19 +2828,19 @@ impl<'a, C, NC, A> TimelineAttachmentListCall<'a, C, NC, A> where NC: hyper::net /// .upload(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct TimelineInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TimelineInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _request: TimelineItem, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TimelineInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TimelineInsertCall<'a, C, A> {} -impl<'a, C, NC, A> TimelineInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TimelineInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3072,7 +3068,7 @@ impl<'a, C, NC, A> TimelineInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &TimelineItem) -> TimelineInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &TimelineItem) -> TimelineInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3083,7 +3079,7 @@ impl<'a, C, NC, A> TimelineInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimelineInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimelineInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3104,7 +3100,7 @@ impl<'a, C, NC, A> TimelineInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TimelineInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TimelineInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3121,7 +3117,7 @@ impl<'a, C, NC, A> TimelineInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TimelineInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TimelineInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3165,10 +3161,10 @@ impl<'a, C, NC, A> TimelineInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct TimelinePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TimelinePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _request: TimelineItem, _id: String, _delegate: Option<&'a mut Delegate>, @@ -3176,9 +3172,9 @@ pub struct TimelinePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TimelinePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TimelinePatchCall<'a, C, A> {} -impl<'a, C, NC, A> TimelinePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TimelinePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3317,7 +3313,7 @@ impl<'a, C, NC, A> TimelinePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &TimelineItem) -> TimelinePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &TimelineItem) -> TimelinePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3327,7 +3323,7 @@ impl<'a, C, NC, A> TimelinePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the timeline item. - pub fn id(mut self, new_value: &str) -> TimelinePatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> TimelinePatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -3338,7 +3334,7 @@ impl<'a, C, NC, A> TimelinePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimelinePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimelinePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3359,7 +3355,7 @@ impl<'a, C, NC, A> TimelinePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TimelinePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TimelinePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3376,7 +3372,7 @@ impl<'a, C, NC, A> TimelinePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TimelinePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TimelinePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3421,10 +3417,10 @@ impl<'a, C, NC, A> TimelinePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct TimelineListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TimelineListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _source_item_id: Option, _pinned_only: Option, _page_token: Option, @@ -3437,9 +3433,9 @@ pub struct TimelineListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TimelineListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TimelineListCall<'a, C, A> {} -impl<'a, C, NC, A> TimelineListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TimelineListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3565,7 +3561,7 @@ impl<'a, C, NC, A> TimelineListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// If provided, only items with the given sourceItemId will be returned. - pub fn source_item_id(mut self, new_value: &str) -> TimelineListCall<'a, C, NC, A> { + pub fn source_item_id(mut self, new_value: &str) -> TimelineListCall<'a, C, A> { self._source_item_id = Some(new_value.to_string()); self } @@ -3573,7 +3569,7 @@ impl<'a, C, NC, A> TimelineListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// If true, only pinned items will be returned. - pub fn pinned_only(mut self, new_value: bool) -> TimelineListCall<'a, C, NC, A> { + pub fn pinned_only(mut self, new_value: bool) -> TimelineListCall<'a, C, A> { self._pinned_only = Some(new_value); self } @@ -3581,7 +3577,7 @@ impl<'a, C, NC, A> TimelineListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Token for the page of results to return. - pub fn page_token(mut self, new_value: &str) -> TimelineListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TimelineListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -3589,7 +3585,7 @@ impl<'a, C, NC, A> TimelineListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Controls the order in which timeline items are returned. - pub fn order_by(mut self, new_value: &str) -> TimelineListCall<'a, C, NC, A> { + pub fn order_by(mut self, new_value: &str) -> TimelineListCall<'a, C, A> { self._order_by = Some(new_value.to_string()); self } @@ -3597,7 +3593,7 @@ impl<'a, C, NC, A> TimelineListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The maximum number of items to include in the response, used for paging. - pub fn max_results(mut self, new_value: u32) -> TimelineListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> TimelineListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -3605,7 +3601,7 @@ impl<'a, C, NC, A> TimelineListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// If true, tombstone records for deleted items will be returned. - pub fn include_deleted(mut self, new_value: bool) -> TimelineListCall<'a, C, NC, A> { + pub fn include_deleted(mut self, new_value: bool) -> TimelineListCall<'a, C, A> { self._include_deleted = Some(new_value); self } @@ -3613,7 +3609,7 @@ impl<'a, C, NC, A> TimelineListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// If provided, only items with the given bundleId will be returned. - pub fn bundle_id(mut self, new_value: &str) -> TimelineListCall<'a, C, NC, A> { + pub fn bundle_id(mut self, new_value: &str) -> TimelineListCall<'a, C, A> { self._bundle_id = Some(new_value.to_string()); self } @@ -3624,7 +3620,7 @@ impl<'a, C, NC, A> TimelineListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimelineListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimelineListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3645,7 +3641,7 @@ impl<'a, C, NC, A> TimelineListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TimelineListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TimelineListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3662,7 +3658,7 @@ impl<'a, C, NC, A> TimelineListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TimelineListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TimelineListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3701,19 +3697,19 @@ impl<'a, C, NC, A> TimelineListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .upload(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct TimelineAttachmentInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TimelineAttachmentInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _item_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TimelineAttachmentInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TimelineAttachmentInsertCall<'a, C, A> {} -impl<'a, C, NC, A> TimelineAttachmentInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TimelineAttachmentInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3954,7 +3950,7 @@ impl<'a, C, NC, A> TimelineAttachmentInsertCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The ID of the timeline item the attachment belongs to. - pub fn item_id(mut self, new_value: &str) -> TimelineAttachmentInsertCall<'a, C, NC, A> { + pub fn item_id(mut self, new_value: &str) -> TimelineAttachmentInsertCall<'a, C, A> { self._item_id = new_value.to_string(); self } @@ -3965,7 +3961,7 @@ impl<'a, C, NC, A> TimelineAttachmentInsertCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimelineAttachmentInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimelineAttachmentInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3986,7 +3982,7 @@ impl<'a, C, NC, A> TimelineAttachmentInsertCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TimelineAttachmentInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TimelineAttachmentInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4003,7 +3999,7 @@ impl<'a, C, NC, A> TimelineAttachmentInsertCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TimelineAttachmentInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TimelineAttachmentInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4041,10 +4037,10 @@ impl<'a, C, NC, A> TimelineAttachmentInsertCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct TimelineAttachmentDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TimelineAttachmentDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _item_id: String, _attachment_id: String, _delegate: Option<&'a mut Delegate>, @@ -4052,9 +4048,9 @@ pub struct TimelineAttachmentDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TimelineAttachmentDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TimelineAttachmentDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> TimelineAttachmentDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TimelineAttachmentDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4176,7 +4172,7 @@ impl<'a, C, NC, A> TimelineAttachmentDeleteCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The ID of the timeline item the attachment belongs to. - pub fn item_id(mut self, new_value: &str) -> TimelineAttachmentDeleteCall<'a, C, NC, A> { + pub fn item_id(mut self, new_value: &str) -> TimelineAttachmentDeleteCall<'a, C, A> { self._item_id = new_value.to_string(); self } @@ -4186,7 +4182,7 @@ impl<'a, C, NC, A> TimelineAttachmentDeleteCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The ID of the attachment. - pub fn attachment_id(mut self, new_value: &str) -> TimelineAttachmentDeleteCall<'a, C, NC, A> { + pub fn attachment_id(mut self, new_value: &str) -> TimelineAttachmentDeleteCall<'a, C, A> { self._attachment_id = new_value.to_string(); self } @@ -4197,7 +4193,7 @@ impl<'a, C, NC, A> TimelineAttachmentDeleteCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimelineAttachmentDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimelineAttachmentDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4218,7 +4214,7 @@ impl<'a, C, NC, A> TimelineAttachmentDeleteCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TimelineAttachmentDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TimelineAttachmentDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4235,7 +4231,7 @@ impl<'a, C, NC, A> TimelineAttachmentDeleteCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TimelineAttachmentDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TimelineAttachmentDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4273,19 +4269,19 @@ impl<'a, C, NC, A> TimelineAttachmentDeleteCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct TimelineDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TimelineDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TimelineDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TimelineDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> TimelineDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TimelineDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4406,7 +4402,7 @@ impl<'a, C, NC, A> TimelineDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the timeline item. - pub fn id(mut self, new_value: &str) -> TimelineDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> TimelineDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -4417,7 +4413,7 @@ impl<'a, C, NC, A> TimelineDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimelineDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimelineDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4438,7 +4434,7 @@ impl<'a, C, NC, A> TimelineDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TimelineDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TimelineDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4455,7 +4451,7 @@ impl<'a, C, NC, A> TimelineDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TimelineDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TimelineDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4500,10 +4496,10 @@ impl<'a, C, NC, A> TimelineDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// .upload(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct TimelineUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TimelineUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _request: TimelineItem, _id: String, _delegate: Option<&'a mut Delegate>, @@ -4511,9 +4507,9 @@ pub struct TimelineUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TimelineUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TimelineUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> TimelineUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TimelineUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4766,7 +4762,7 @@ impl<'a, C, NC, A> TimelineUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &TimelineItem) -> TimelineUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &TimelineItem) -> TimelineUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4776,7 +4772,7 @@ impl<'a, C, NC, A> TimelineUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the timeline item. - pub fn id(mut self, new_value: &str) -> TimelineUpdateCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> TimelineUpdateCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -4787,7 +4783,7 @@ impl<'a, C, NC, A> TimelineUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimelineUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimelineUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4808,7 +4804,7 @@ impl<'a, C, NC, A> TimelineUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TimelineUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TimelineUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4825,7 +4821,7 @@ impl<'a, C, NC, A> TimelineUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TimelineUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TimelineUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4868,10 +4864,10 @@ impl<'a, C, NC, A> TimelineUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct TimelineAttachmentGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TimelineAttachmentGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _item_id: String, _attachment_id: String, _delegate: Option<&'a mut Delegate>, @@ -4879,9 +4875,9 @@ pub struct TimelineAttachmentGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TimelineAttachmentGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TimelineAttachmentGetCall<'a, C, A> {} -impl<'a, C, NC, A> TimelineAttachmentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TimelineAttachmentGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5030,7 +5026,7 @@ impl<'a, C, NC, A> TimelineAttachmentGetCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The ID of the timeline item the attachment belongs to. - pub fn item_id(mut self, new_value: &str) -> TimelineAttachmentGetCall<'a, C, NC, A> { + pub fn item_id(mut self, new_value: &str) -> TimelineAttachmentGetCall<'a, C, A> { self._item_id = new_value.to_string(); self } @@ -5040,7 +5036,7 @@ impl<'a, C, NC, A> TimelineAttachmentGetCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The ID of the attachment. - pub fn attachment_id(mut self, new_value: &str) -> TimelineAttachmentGetCall<'a, C, NC, A> { + pub fn attachment_id(mut self, new_value: &str) -> TimelineAttachmentGetCall<'a, C, A> { self._attachment_id = new_value.to_string(); self } @@ -5051,7 +5047,7 @@ impl<'a, C, NC, A> TimelineAttachmentGetCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimelineAttachmentGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimelineAttachmentGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5072,7 +5068,7 @@ impl<'a, C, NC, A> TimelineAttachmentGetCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TimelineAttachmentGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TimelineAttachmentGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5089,7 +5085,7 @@ impl<'a, C, NC, A> TimelineAttachmentGetCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TimelineAttachmentGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TimelineAttachmentGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5127,19 +5123,19 @@ impl<'a, C, NC, A> TimelineAttachmentGetCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct TimelineGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TimelineGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TimelineGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TimelineGetCall<'a, C, A> {} -impl<'a, C, NC, A> TimelineGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TimelineGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5271,7 +5267,7 @@ impl<'a, C, NC, A> TimelineGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the timeline item. - pub fn id(mut self, new_value: &str) -> TimelineGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> TimelineGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -5282,7 +5278,7 @@ impl<'a, C, NC, A> TimelineGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimelineGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TimelineGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5303,7 +5299,7 @@ impl<'a, C, NC, A> TimelineGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TimelineGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TimelineGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5320,7 +5316,7 @@ impl<'a, C, NC, A> TimelineGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TimelineGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TimelineGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5358,19 +5354,19 @@ impl<'a, C, NC, A> TimelineGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct SettingGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SettingGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SettingGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SettingGetCall<'a, C, A> {} -impl<'a, C, NC, A> SettingGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SettingGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5504,7 +5500,7 @@ impl<'a, C, NC, A> SettingGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// The ID of the setting. The following IDs are valid: /// - locale - The key to the user’s language/locale (BCP 47 identifier) that Glassware should use to render localized content. /// - timezone - The key to the user’s current time zone region as defined in the tz database. Example: America/Los_Angeles. - pub fn id(mut self, new_value: &str) -> SettingGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> SettingGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -5515,7 +5511,7 @@ impl<'a, C, NC, A> SettingGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SettingGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SettingGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5536,7 +5532,7 @@ impl<'a, C, NC, A> SettingGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SettingGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SettingGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5553,7 +5549,7 @@ impl<'a, C, NC, A> SettingGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SettingGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SettingGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5591,19 +5587,19 @@ impl<'a, C, NC, A> SettingGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct LocationGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LocationGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LocationGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LocationGetCall<'a, C, A> {} -impl<'a, C, NC, A> LocationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LocationGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5735,7 +5731,7 @@ impl<'a, C, NC, A> LocationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the location or latest for the last known location. - pub fn id(mut self, new_value: &str) -> LocationGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> LocationGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -5746,7 +5742,7 @@ impl<'a, C, NC, A> LocationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LocationGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LocationGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5767,7 +5763,7 @@ impl<'a, C, NC, A> LocationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LocationGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LocationGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5784,7 +5780,7 @@ impl<'a, C, NC, A> LocationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LocationGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LocationGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5822,18 +5818,18 @@ impl<'a, C, NC, A> LocationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct LocationListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LocationListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LocationListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LocationListCall<'a, C, A> {} -impl<'a, C, NC, A> LocationListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LocationListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5941,7 +5937,7 @@ impl<'a, C, NC, A> LocationListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LocationListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LocationListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5962,7 +5958,7 @@ impl<'a, C, NC, A> LocationListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LocationListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LocationListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5979,7 +5975,7 @@ impl<'a, C, NC, A> LocationListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LocationListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LocationListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6023,10 +6019,10 @@ impl<'a, C, NC, A> LocationListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct AccountInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _request: Account, _user_token: String, _account_type: String, @@ -6036,9 +6032,9 @@ pub struct AccountInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountInsertCall<'a, C, A> {} -impl<'a, C, NC, A> AccountInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6179,7 +6175,7 @@ impl<'a, C, NC, A> AccountInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Account) -> AccountInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Account) -> AccountInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6189,7 +6185,7 @@ impl<'a, C, NC, A> AccountInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID for the user. - pub fn user_token(mut self, new_value: &str) -> AccountInsertCall<'a, C, NC, A> { + pub fn user_token(mut self, new_value: &str) -> AccountInsertCall<'a, C, A> { self._user_token = new_value.to_string(); self } @@ -6199,7 +6195,7 @@ impl<'a, C, NC, A> AccountInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Account type to be passed to Android Account Manager. - pub fn account_type(mut self, new_value: &str) -> AccountInsertCall<'a, C, NC, A> { + pub fn account_type(mut self, new_value: &str) -> AccountInsertCall<'a, C, A> { self._account_type = new_value.to_string(); self } @@ -6209,7 +6205,7 @@ impl<'a, C, NC, A> AccountInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The name of the account to be passed to the Android Account Manager. - pub fn account_name(mut self, new_value: &str) -> AccountInsertCall<'a, C, NC, A> { + pub fn account_name(mut self, new_value: &str) -> AccountInsertCall<'a, C, A> { self._account_name = new_value.to_string(); self } @@ -6220,7 +6216,7 @@ impl<'a, C, NC, A> AccountInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6241,7 +6237,7 @@ impl<'a, C, NC, A> AccountInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6258,7 +6254,7 @@ impl<'a, C, NC, A> AccountInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6296,19 +6292,19 @@ impl<'a, C, NC, A> AccountInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct ContactGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ContactGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ContactGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ContactGetCall<'a, C, A> {} -impl<'a, C, NC, A> ContactGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ContactGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6440,7 +6436,7 @@ impl<'a, C, NC, A> ContactGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the contact. - pub fn id(mut self, new_value: &str) -> ContactGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> ContactGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -6451,7 +6447,7 @@ impl<'a, C, NC, A> ContactGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContactGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContactGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6472,7 +6468,7 @@ impl<'a, C, NC, A> ContactGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ContactGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ContactGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6489,7 +6485,7 @@ impl<'a, C, NC, A> ContactGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ContactGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ContactGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6527,19 +6523,19 @@ impl<'a, C, NC, A> ContactGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct ContactDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ContactDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ContactDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ContactDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ContactDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ContactDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6660,7 +6656,7 @@ impl<'a, C, NC, A> ContactDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the contact. - pub fn id(mut self, new_value: &str) -> ContactDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> ContactDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -6671,7 +6667,7 @@ impl<'a, C, NC, A> ContactDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContactDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContactDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6692,7 +6688,7 @@ impl<'a, C, NC, A> ContactDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ContactDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ContactDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6709,7 +6705,7 @@ impl<'a, C, NC, A> ContactDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ContactDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ContactDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6753,19 +6749,19 @@ impl<'a, C, NC, A> ContactDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct ContactInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ContactInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _request: Contact, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ContactInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ContactInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ContactInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ContactInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6879,7 +6875,7 @@ impl<'a, C, NC, A> ContactInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Contact) -> ContactInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Contact) -> ContactInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6890,7 +6886,7 @@ impl<'a, C, NC, A> ContactInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContactInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContactInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6911,7 +6907,7 @@ impl<'a, C, NC, A> ContactInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ContactInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ContactInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6928,7 +6924,7 @@ impl<'a, C, NC, A> ContactInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ContactInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ContactInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6972,10 +6968,10 @@ impl<'a, C, NC, A> ContactInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct ContactPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ContactPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _request: Contact, _id: String, _delegate: Option<&'a mut Delegate>, @@ -6983,9 +6979,9 @@ pub struct ContactPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ContactPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ContactPatchCall<'a, C, A> {} -impl<'a, C, NC, A> ContactPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ContactPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7124,7 +7120,7 @@ impl<'a, C, NC, A> ContactPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Contact) -> ContactPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Contact) -> ContactPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7134,7 +7130,7 @@ impl<'a, C, NC, A> ContactPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the contact. - pub fn id(mut self, new_value: &str) -> ContactPatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> ContactPatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -7145,7 +7141,7 @@ impl<'a, C, NC, A> ContactPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContactPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContactPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7166,7 +7162,7 @@ impl<'a, C, NC, A> ContactPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ContactPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ContactPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7183,7 +7179,7 @@ impl<'a, C, NC, A> ContactPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ContactPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ContactPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7221,18 +7217,18 @@ impl<'a, C, NC, A> ContactPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct ContactListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ContactListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ContactListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ContactListCall<'a, C, A> {} -impl<'a, C, NC, A> ContactListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ContactListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7340,7 +7336,7 @@ impl<'a, C, NC, A> ContactListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContactListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContactListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7361,7 +7357,7 @@ impl<'a, C, NC, A> ContactListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ContactListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ContactListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7378,7 +7374,7 @@ impl<'a, C, NC, A> ContactListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ContactListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ContactListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7422,10 +7418,10 @@ impl<'a, C, NC, A> ContactListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct ContactUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ContactUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Mirror, + hub: &'a Mirror, _request: Contact, _id: String, _delegate: Option<&'a mut Delegate>, @@ -7433,9 +7429,9 @@ pub struct ContactUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ContactUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ContactUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ContactUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ContactUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7574,7 +7570,7 @@ impl<'a, C, NC, A> ContactUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Contact) -> ContactUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Contact) -> ContactUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7584,7 +7580,7 @@ impl<'a, C, NC, A> ContactUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the contact. - pub fn id(mut self, new_value: &str) -> ContactUpdateCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> ContactUpdateCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -7595,7 +7591,7 @@ impl<'a, C, NC, A> ContactUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContactUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ContactUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7616,7 +7612,7 @@ impl<'a, C, NC, A> ContactUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ContactUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ContactUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7633,7 +7629,7 @@ impl<'a, C, NC, A> ContactUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ContactUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ContactUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/oauth2_v2/Cargo.toml b/gen/oauth2_v2/Cargo.toml index 3fd77dc6b44..3492eea239f 100644 --- a/gen/oauth2_v2/Cargo.toml +++ b/gen/oauth2_v2/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-oauth2_v2" -version = "0.1.4+20150319" +version = "0.1.5+20150319" authors = ["Sebastian Thiel "] description = "A complete library to interact with oauth2 (protocol v2)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/oauth2_v2" homepage = "https://developers.google.com/accounts/docs/OAuth2" -documentation = "http://byron.github.io/google-apis-rs/google-oauth2_v2" +documentation = "http://byron.github.io/google-apis-rs/google_oauth2_v2" license = "MIT" keywords = ["oauth2", "google", "protocol", "web", "api"] diff --git a/gen/oauth2_v2/README.md b/gen/oauth2_v2/README.md index 9ef9e6bb00c..cf0d85869f4 100644 --- a/gen/oauth2_v2/README.md +++ b/gen/oauth2_v2/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-oauth2_v2` library allows access to all features of the *Google oauth2* service. -This documentation was generated from *oauth2* crate version *0.1.4+20150319*, where *20150319* is the exact revision of the *oauth2:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *oauth2* crate version *0.1.5+20150319*, where *20150319* is the exact revision of the *oauth2:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *oauth2* *v2* API can be found at the [official documentation site](https://developers.google.com/accounts/docs/OAuth2). diff --git a/gen/oauth2_v2/src/cmn.rs b/gen/oauth2_v2/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/oauth2_v2/src/cmn.rs +++ b/gen/oauth2_v2/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/oauth2_v2/src/lib.rs b/gen/oauth2_v2/src/lib.rs index 4ec5d6775d3..4f43aaba5a3 100644 --- a/gen/oauth2_v2/src/lib.rs +++ b/gen/oauth2_v2/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *oauth2* crate version *0.1.4+20150319*, where *20150319* is the exact revision of the *oauth2:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *oauth2* crate version *0.1.5+20150319*, where *20150319* is the exact revision of the *oauth2:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *oauth2* *v2* API can be found at the //! [official documentation site](https://developers.google.com/accounts/docs/OAuth2). @@ -193,7 +193,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -296,37 +295,34 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Oauth2 { +pub struct Oauth2 { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Oauth2 {} +impl<'a, C, A> Hub for Oauth2 {} -impl<'a, C, NC, A> Oauth2 - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Oauth2 + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Oauth2 { + pub fn new(client: C, authenticator: A) -> Oauth2 { Oauth2 { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn methods(&'a self) -> MethodMethods<'a, C, NC, A> { + pub fn methods(&'a self) -> MethodMethods<'a, C, A> { MethodMethods { hub: &self } } - pub fn userinfo(&'a self) -> UserinfoMethods<'a, C, NC, A> { + pub fn userinfo(&'a self) -> UserinfoMethods<'a, C, A> { UserinfoMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -489,17 +485,17 @@ impl ResponseResult for Tokeninfo {} /// let rb = hub.userinfo(); /// # } /// ``` -pub struct UserinfoMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserinfoMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Oauth2, + hub: &'a Oauth2, } -impl<'a, C, NC, A> MethodsBuilder for UserinfoMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for UserinfoMethods<'a, C, A> {} -impl<'a, C, NC, A> UserinfoMethods<'a, C, NC, A> { +impl<'a, C, A> UserinfoMethods<'a, C, A> { - pub fn v2_me_get(&self) -> UserinfoV2MeGetCall<'a, C, NC, A> { + pub fn v2_me_get(&self) -> UserinfoV2MeGetCall<'a, C, A> { UserinfoV2MeGetCall { hub: self.hub, _delegate: Default::default(), @@ -508,7 +504,7 @@ impl<'a, C, NC, A> UserinfoMethods<'a, C, NC, A> { } } - pub fn get(&self) -> UserinfoGetCall<'a, C, NC, A> { + pub fn get(&self) -> UserinfoGetCall<'a, C, A> { UserinfoGetCall { hub: self.hub, _delegate: Default::default(), @@ -548,17 +544,17 @@ impl<'a, C, NC, A> UserinfoMethods<'a, C, NC, A> { /// let rb = hub.methods(); /// # } /// ``` -pub struct MethodMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MethodMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Oauth2, + hub: &'a Oauth2, } -impl<'a, C, NC, A> MethodsBuilder for MethodMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for MethodMethods<'a, C, A> {} -impl<'a, C, NC, A> MethodMethods<'a, C, NC, A> { +impl<'a, C, A> MethodMethods<'a, C, A> { - pub fn tokeninfo(&self) -> MethodTokeninfoCall<'a, C, NC, A> { + pub fn tokeninfo(&self) -> MethodTokeninfoCall<'a, C, A> { MethodTokeninfoCall { hub: self.hub, _token_handle: Default::default(), @@ -570,7 +566,7 @@ impl<'a, C, NC, A> MethodMethods<'a, C, NC, A> { } } - pub fn get_cert_for_open_id_connect(&self) -> MethodGetCertForOpenIdConnectCall<'a, C, NC, A> { + pub fn get_cert_for_open_id_connect(&self) -> MethodGetCertForOpenIdConnectCall<'a, C, A> { MethodGetCertForOpenIdConnectCall { hub: self.hub, _delegate: Default::default(), @@ -616,18 +612,18 @@ impl<'a, C, NC, A> MethodMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct UserinfoV2MeGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserinfoV2MeGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Oauth2, + hub: &'a Oauth2, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserinfoV2MeGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserinfoV2MeGetCall<'a, C, A> {} -impl<'a, C, NC, A> UserinfoV2MeGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserinfoV2MeGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -735,7 +731,7 @@ impl<'a, C, NC, A> UserinfoV2MeGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserinfoV2MeGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserinfoV2MeGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -756,7 +752,7 @@ impl<'a, C, NC, A> UserinfoV2MeGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserinfoV2MeGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserinfoV2MeGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -773,7 +769,7 @@ impl<'a, C, NC, A> UserinfoV2MeGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserinfoV2MeGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserinfoV2MeGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -809,18 +805,18 @@ impl<'a, C, NC, A> UserinfoV2MeGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct UserinfoGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserinfoGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Oauth2, + hub: &'a Oauth2, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserinfoGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserinfoGetCall<'a, C, A> {} -impl<'a, C, NC, A> UserinfoGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserinfoGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -928,7 +924,7 @@ impl<'a, C, NC, A> UserinfoGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserinfoGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserinfoGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -949,7 +945,7 @@ impl<'a, C, NC, A> UserinfoGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserinfoGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserinfoGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -966,7 +962,7 @@ impl<'a, C, NC, A> UserinfoGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserinfoGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserinfoGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1005,10 +1001,10 @@ impl<'a, C, NC, A> UserinfoGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct MethodTokeninfoCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MethodTokeninfoCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Oauth2, + hub: &'a Oauth2, _token_handle: Option, _id_token: Option, _access_token: Option, @@ -1017,9 +1013,9 @@ pub struct MethodTokeninfoCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MethodTokeninfoCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MethodTokeninfoCall<'a, C, A> {} -impl<'a, C, NC, A> MethodTokeninfoCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MethodTokeninfoCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1132,21 +1128,21 @@ impl<'a, C, NC, A> MethodTokeninfoCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Sets the *token_handle* query property to the given value. /// /// - pub fn token_handle(mut self, new_value: &str) -> MethodTokeninfoCall<'a, C, NC, A> { + pub fn token_handle(mut self, new_value: &str) -> MethodTokeninfoCall<'a, C, A> { self._token_handle = Some(new_value.to_string()); self } /// Sets the *id_token* query property to the given value. /// /// - pub fn id_token(mut self, new_value: &str) -> MethodTokeninfoCall<'a, C, NC, A> { + pub fn id_token(mut self, new_value: &str) -> MethodTokeninfoCall<'a, C, A> { self._id_token = Some(new_value.to_string()); self } /// Sets the *access_token* query property to the given value. /// /// - pub fn access_token(mut self, new_value: &str) -> MethodTokeninfoCall<'a, C, NC, A> { + pub fn access_token(mut self, new_value: &str) -> MethodTokeninfoCall<'a, C, A> { self._access_token = Some(new_value.to_string()); self } @@ -1157,7 +1153,7 @@ impl<'a, C, NC, A> MethodTokeninfoCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MethodTokeninfoCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MethodTokeninfoCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1178,7 +1174,7 @@ impl<'a, C, NC, A> MethodTokeninfoCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MethodTokeninfoCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MethodTokeninfoCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1195,7 +1191,7 @@ impl<'a, C, NC, A> MethodTokeninfoCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MethodTokeninfoCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MethodTokeninfoCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1231,18 +1227,18 @@ impl<'a, C, NC, A> MethodTokeninfoCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct MethodGetCertForOpenIdConnectCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MethodGetCertForOpenIdConnectCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Oauth2, + hub: &'a Oauth2, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MethodGetCertForOpenIdConnectCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MethodGetCertForOpenIdConnectCall<'a, C, A> {} -impl<'a, C, NC, A> MethodGetCertForOpenIdConnectCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MethodGetCertForOpenIdConnectCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1350,7 +1346,7 @@ impl<'a, C, NC, A> MethodGetCertForOpenIdConnectCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MethodGetCertForOpenIdConnectCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MethodGetCertForOpenIdConnectCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1371,7 +1367,7 @@ impl<'a, C, NC, A> MethodGetCertForOpenIdConnectCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MethodGetCertForOpenIdConnectCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MethodGetCertForOpenIdConnectCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1388,7 +1384,7 @@ impl<'a, C, NC, A> MethodGetCertForOpenIdConnectCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MethodGetCertForOpenIdConnectCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MethodGetCertForOpenIdConnectCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/pagespeedonline2/Cargo.toml b/gen/pagespeedonline2/Cargo.toml index 390f27e6c2f..db171a51720 100644 --- a/gen/pagespeedonline2/Cargo.toml +++ b/gen/pagespeedonline2/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-pagespeedonline2" -version = "0.1.4+20150317" +version = "0.1.5+20150317" authors = ["Sebastian Thiel "] description = "A complete library to interact with pagespeedonline (protocol v2)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/pagespeedonline2" homepage = "https://developers.google.com/speed/docs/insights/v2/getting-started" -documentation = "http://byron.github.io/google-apis-rs/google-pagespeedonline2" +documentation = "http://byron.github.io/google-apis-rs/google_pagespeedonline2" license = "MIT" keywords = ["pagespeedonline", "google", "protocol", "web", "api"] diff --git a/gen/pagespeedonline2/README.md b/gen/pagespeedonline2/README.md index 600f5233395..e34989cd10a 100644 --- a/gen/pagespeedonline2/README.md +++ b/gen/pagespeedonline2/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-pagespeedonline2` library allows access to all features of the *Google pagespeedonline* service. -This documentation was generated from *pagespeedonline* crate version *0.1.4+20150317*, where *20150317* is the exact revision of the *pagespeedonline:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *pagespeedonline* crate version *0.1.5+20150317*, where *20150317* is the exact revision of the *pagespeedonline:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *pagespeedonline* *v2* API can be found at the [official documentation site](https://developers.google.com/speed/docs/insights/v2/getting-started). diff --git a/gen/pagespeedonline2/src/cmn.rs b/gen/pagespeedonline2/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/pagespeedonline2/src/cmn.rs +++ b/gen/pagespeedonline2/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/pagespeedonline2/src/lib.rs b/gen/pagespeedonline2/src/lib.rs index 3d2bc2643df..250a4625834 100644 --- a/gen/pagespeedonline2/src/lib.rs +++ b/gen/pagespeedonline2/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *pagespeedonline* crate version *0.1.4+20150317*, where *20150317* is the exact revision of the *pagespeedonline:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *pagespeedonline* crate version *0.1.5+20150317*, where *20150317* is the exact revision of the *pagespeedonline:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *pagespeedonline* *v2* API can be found at the //! [official documentation site](https://developers.google.com/speed/docs/insights/v2/getting-started). @@ -193,7 +193,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -267,34 +266,31 @@ pub use cmn::{MultiPartReader, ToParts, MethodInfo, Result, Error, CallBuilder, /// } /// # } /// ``` -pub struct Pagespeedonline { +pub struct Pagespeedonline { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Pagespeedonline {} +impl<'a, C, A> Hub for Pagespeedonline {} -impl<'a, C, NC, A> Pagespeedonline - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Pagespeedonline + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Pagespeedonline { + pub fn new(client: C, authenticator: A) -> Pagespeedonline { Pagespeedonline { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn pagespeedapi(&'a self) -> PagespeedapiMethods<'a, C, NC, A> { + pub fn pagespeedapi(&'a self) -> PagespeedapiMethods<'a, C, A> { PagespeedapiMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -658,15 +654,15 @@ impl Part for ResultRuleGroups {} /// let rb = hub.pagespeedapi(); /// # } /// ``` -pub struct PagespeedapiMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PagespeedapiMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Pagespeedonline, + hub: &'a Pagespeedonline, } -impl<'a, C, NC, A> MethodsBuilder for PagespeedapiMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PagespeedapiMethods<'a, C, A> {} -impl<'a, C, NC, A> PagespeedapiMethods<'a, C, NC, A> { +impl<'a, C, A> PagespeedapiMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -675,7 +671,7 @@ impl<'a, C, NC, A> PagespeedapiMethods<'a, C, NC, A> { /// # Arguments /// /// * `url` - The URL to fetch and analyze - pub fn runpagespeed(&self, url: &str) -> PagespeedapiRunpagespeedCall<'a, C, NC, A> { + pub fn runpagespeed(&self, url: &str) -> PagespeedapiRunpagespeedCall<'a, C, A> { PagespeedapiRunpagespeedCall { hub: self.hub, _url: url.to_string(), @@ -733,10 +729,10 @@ impl<'a, C, NC, A> PagespeedapiMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct PagespeedapiRunpagespeedCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PagespeedapiRunpagespeedCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Pagespeedonline, + hub: &'a Pagespeedonline, _url: String, _strategy: Option, _screenshot: Option, @@ -747,9 +743,9 @@ pub struct PagespeedapiRunpagespeedCall<'a, C, NC, A> _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for PagespeedapiRunpagespeedCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PagespeedapiRunpagespeedCall<'a, C, A> {} -impl<'a, C, NC, A> PagespeedapiRunpagespeedCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PagespeedapiRunpagespeedCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -874,7 +870,7 @@ impl<'a, C, NC, A> PagespeedapiRunpagespeedCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The URL to fetch and analyze - pub fn url(mut self, new_value: &str) -> PagespeedapiRunpagespeedCall<'a, C, NC, A> { + pub fn url(mut self, new_value: &str) -> PagespeedapiRunpagespeedCall<'a, C, A> { self._url = new_value.to_string(); self } @@ -882,7 +878,7 @@ impl<'a, C, NC, A> PagespeedapiRunpagespeedCall<'a, C, NC, A> where NC: hyper::n /// /// /// The analysis strategy to use - pub fn strategy(mut self, new_value: &str) -> PagespeedapiRunpagespeedCall<'a, C, NC, A> { + pub fn strategy(mut self, new_value: &str) -> PagespeedapiRunpagespeedCall<'a, C, A> { self._strategy = Some(new_value.to_string()); self } @@ -890,7 +886,7 @@ impl<'a, C, NC, A> PagespeedapiRunpagespeedCall<'a, C, NC, A> where NC: hyper::n /// /// /// Indicates if binary data containing a screenshot should be included - pub fn screenshot(mut self, new_value: bool) -> PagespeedapiRunpagespeedCall<'a, C, NC, A> { + pub fn screenshot(mut self, new_value: bool) -> PagespeedapiRunpagespeedCall<'a, C, A> { self._screenshot = Some(new_value); self } @@ -899,7 +895,7 @@ impl<'a, C, NC, A> PagespeedapiRunpagespeedCall<'a, C, NC, A> where NC: hyper::n /// /// /// A PageSpeed rule to run; if none are given, all rules are run - pub fn add_rule(mut self, new_value: &str) -> PagespeedapiRunpagespeedCall<'a, C, NC, A> { + pub fn add_rule(mut self, new_value: &str) -> PagespeedapiRunpagespeedCall<'a, C, A> { self._rule.push(new_value.to_string()); self } @@ -907,7 +903,7 @@ impl<'a, C, NC, A> PagespeedapiRunpagespeedCall<'a, C, NC, A> where NC: hyper::n /// /// /// The locale used to localize formatted results - pub fn locale(mut self, new_value: &str) -> PagespeedapiRunpagespeedCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> PagespeedapiRunpagespeedCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -915,7 +911,7 @@ impl<'a, C, NC, A> PagespeedapiRunpagespeedCall<'a, C, NC, A> where NC: hyper::n /// /// /// Indicates if third party resources should be filtered out before PageSpeed analysis. - pub fn filter_third_party_resources(mut self, new_value: bool) -> PagespeedapiRunpagespeedCall<'a, C, NC, A> { + pub fn filter_third_party_resources(mut self, new_value: bool) -> PagespeedapiRunpagespeedCall<'a, C, A> { self._filter_third_party_resources = Some(new_value); self } @@ -926,7 +922,7 @@ impl<'a, C, NC, A> PagespeedapiRunpagespeedCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PagespeedapiRunpagespeedCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PagespeedapiRunpagespeedCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -947,7 +943,7 @@ impl<'a, C, NC, A> PagespeedapiRunpagespeedCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PagespeedapiRunpagespeedCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PagespeedapiRunpagespeedCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self diff --git a/gen/plus1/Cargo.toml b/gen/plus1/Cargo.toml index b7746df5f67..c3fff6cc057 100644 --- a/gen/plus1/Cargo.toml +++ b/gen/plus1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-plus1" -version = "0.1.4+20150326" +version = "0.1.5+20150326" authors = ["Sebastian Thiel "] description = "A complete library to interact with plus (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/plus1" homepage = "https://developers.google.com/+/api/" -documentation = "http://byron.github.io/google-apis-rs/google-plus1" +documentation = "http://byron.github.io/google-apis-rs/google_plus1" license = "MIT" keywords = ["plus", "google", "protocol", "web", "api"] diff --git a/gen/plus1/README.md b/gen/plus1/README.md index 73870e5e723..dd9a3e9e716 100644 --- a/gen/plus1/README.md +++ b/gen/plus1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-plus1` library allows access to all features of the *Google plus* service. -This documentation was generated from *plus* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *plus:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *plus* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *plus:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *plus* *v1* API can be found at the [official documentation site](https://developers.google.com/+/api/). diff --git a/gen/plus1/src/cmn.rs b/gen/plus1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/plus1/src/cmn.rs +++ b/gen/plus1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/plus1/src/lib.rs b/gen/plus1/src/lib.rs index f718dbb2b8c..4856a48fcdc 100644 --- a/gen/plus1/src/lib.rs +++ b/gen/plus1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *plus* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *plus:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *plus* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *plus:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *plus* *v1* API can be found at the //! [official documentation site](https://developers.google.com/+/api/). @@ -199,7 +199,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -305,43 +304,40 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Plus { +pub struct Plus { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Plus {} +impl<'a, C, A> Hub for Plus {} -impl<'a, C, NC, A> Plus - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Plus + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Plus { + pub fn new(client: C, authenticator: A) -> Plus { Plus { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn activities(&'a self) -> ActivityMethods<'a, C, NC, A> { + pub fn activities(&'a self) -> ActivityMethods<'a, C, A> { ActivityMethods { hub: &self } } - pub fn comments(&'a self) -> CommentMethods<'a, C, NC, A> { + pub fn comments(&'a self) -> CommentMethods<'a, C, A> { CommentMethods { hub: &self } } - pub fn moments(&'a self) -> MomentMethods<'a, C, NC, A> { + pub fn moments(&'a self) -> MomentMethods<'a, C, A> { MomentMethods { hub: &self } } - pub fn people(&'a self) -> PeopleMethods<'a, C, NC, A> { + pub fn people(&'a self) -> PeopleMethods<'a, C, A> { PeopleMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -1650,15 +1646,15 @@ impl Part for Place {} /// let rb = hub.moments(); /// # } /// ``` -pub struct MomentMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MomentMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Plus, + hub: &'a Plus, } -impl<'a, C, NC, A> MethodsBuilder for MomentMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for MomentMethods<'a, C, A> {} -impl<'a, C, NC, A> MomentMethods<'a, C, NC, A> { +impl<'a, C, A> MomentMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1669,7 +1665,7 @@ impl<'a, C, NC, A> MomentMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `userId` - The ID of the user to record actions for. The only valid values are "me" and the ID of the authenticated user. /// * `collection` - The collection to which to write moments. - pub fn insert(&self, request: &Moment, user_id: &str, collection: &str) -> MomentInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Moment, user_id: &str, collection: &str) -> MomentInsertCall<'a, C, A> { MomentInsertCall { hub: self.hub, _request: request.clone(), @@ -1690,7 +1686,7 @@ impl<'a, C, NC, A> MomentMethods<'a, C, NC, A> { /// /// * `userId` - The ID of the user to get moments for. The special value "me" can be used to indicate the authenticated user. /// * `collection` - The collection of moments to list. - pub fn list(&self, user_id: &str, collection: &str) -> MomentListCall<'a, C, NC, A> { + pub fn list(&self, user_id: &str, collection: &str) -> MomentListCall<'a, C, A> { MomentListCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1712,7 +1708,7 @@ impl<'a, C, NC, A> MomentMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The ID of the moment to delete. - pub fn remove(&self, id: &str) -> MomentRemoveCall<'a, C, NC, A> { + pub fn remove(&self, id: &str) -> MomentRemoveCall<'a, C, A> { MomentRemoveCall { hub: self.hub, _id: id.to_string(), @@ -1753,15 +1749,15 @@ impl<'a, C, NC, A> MomentMethods<'a, C, NC, A> { /// let rb = hub.activities(); /// # } /// ``` -pub struct ActivityMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ActivityMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Plus, + hub: &'a Plus, } -impl<'a, C, NC, A> MethodsBuilder for ActivityMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ActivityMethods<'a, C, A> {} -impl<'a, C, NC, A> ActivityMethods<'a, C, NC, A> { +impl<'a, C, A> ActivityMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1770,7 +1766,7 @@ impl<'a, C, NC, A> ActivityMethods<'a, C, NC, A> { /// # Arguments /// /// * `query` - Full-text search query string. - pub fn search(&self, query: &str) -> ActivitySearchCall<'a, C, NC, A> { + pub fn search(&self, query: &str) -> ActivitySearchCall<'a, C, A> { ActivitySearchCall { hub: self.hub, _query: query.to_string(), @@ -1791,7 +1787,7 @@ impl<'a, C, NC, A> ActivityMethods<'a, C, NC, A> { /// # Arguments /// /// * `activityId` - The ID of the activity to get. - pub fn get(&self, activity_id: &str) -> ActivityGetCall<'a, C, NC, A> { + pub fn get(&self, activity_id: &str) -> ActivityGetCall<'a, C, A> { ActivityGetCall { hub: self.hub, _activity_id: activity_id.to_string(), @@ -1809,7 +1805,7 @@ impl<'a, C, NC, A> ActivityMethods<'a, C, NC, A> { /// /// * `userId` - The ID of the user to get activities for. The special value "me" can be used to indicate the authenticated user. /// * `collection` - The collection of activities to list. - pub fn list(&self, user_id: &str, collection: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn list(&self, user_id: &str, collection: &str) -> ActivityListCall<'a, C, A> { ActivityListCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1853,15 +1849,15 @@ impl<'a, C, NC, A> ActivityMethods<'a, C, NC, A> { /// let rb = hub.comments(); /// # } /// ``` -pub struct CommentMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CommentMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Plus, + hub: &'a Plus, } -impl<'a, C, NC, A> MethodsBuilder for CommentMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CommentMethods<'a, C, A> {} -impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { +impl<'a, C, A> CommentMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1870,7 +1866,7 @@ impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { /// # Arguments /// /// * `activityId` - The ID of the activity to get comments for. - pub fn list(&self, activity_id: &str) -> CommentListCall<'a, C, NC, A> { + pub fn list(&self, activity_id: &str) -> CommentListCall<'a, C, A> { CommentListCall { hub: self.hub, _activity_id: activity_id.to_string(), @@ -1890,7 +1886,7 @@ impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { /// # Arguments /// /// * `commentId` - The ID of the comment to get. - pub fn get(&self, comment_id: &str) -> CommentGetCall<'a, C, NC, A> { + pub fn get(&self, comment_id: &str) -> CommentGetCall<'a, C, A> { CommentGetCall { hub: self.hub, _comment_id: comment_id.to_string(), @@ -1931,15 +1927,15 @@ impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { /// let rb = hub.people(); /// # } /// ``` -pub struct PeopleMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PeopleMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Plus, + hub: &'a Plus, } -impl<'a, C, NC, A> MethodsBuilder for PeopleMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PeopleMethods<'a, C, A> {} -impl<'a, C, NC, A> PeopleMethods<'a, C, NC, A> { +impl<'a, C, A> PeopleMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1948,7 +1944,7 @@ impl<'a, C, NC, A> PeopleMethods<'a, C, NC, A> { /// # Arguments /// /// * `query` - Specify a query string for full text search of public text in all profiles. - pub fn search(&self, query: &str) -> PeopleSearchCall<'a, C, NC, A> { + pub fn search(&self, query: &str) -> PeopleSearchCall<'a, C, A> { PeopleSearchCall { hub: self.hub, _query: query.to_string(), @@ -1969,7 +1965,7 @@ impl<'a, C, NC, A> PeopleMethods<'a, C, NC, A> { /// /// * `activityId` - The ID of the activity to get the list of people for. /// * `collection` - The collection of people to list. - pub fn list_by_activity(&self, activity_id: &str, collection: &str) -> PeopleListByActivityCall<'a, C, NC, A> { + pub fn list_by_activity(&self, activity_id: &str, collection: &str) -> PeopleListByActivityCall<'a, C, A> { PeopleListByActivityCall { hub: self.hub, _activity_id: activity_id.to_string(), @@ -1990,7 +1986,7 @@ impl<'a, C, NC, A> PeopleMethods<'a, C, NC, A> { /// /// * `userId` - Get the collection of people for the person identified. Use "me" to indicate the authenticated user. /// * `collection` - The collection of people to list. - pub fn list(&self, user_id: &str, collection: &str) -> PeopleListCall<'a, C, NC, A> { + pub fn list(&self, user_id: &str, collection: &str) -> PeopleListCall<'a, C, A> { PeopleListCall { hub: self.hub, _user_id: user_id.to_string(), @@ -2011,7 +2007,7 @@ impl<'a, C, NC, A> PeopleMethods<'a, C, NC, A> { /// # Arguments /// /// * `userId` - The ID of the person to get the profile for. The special value "me" can be used to indicate the authenticated user. - pub fn get(&self, user_id: &str) -> PeopleGetCall<'a, C, NC, A> { + pub fn get(&self, user_id: &str) -> PeopleGetCall<'a, C, A> { PeopleGetCall { hub: self.hub, _user_id: user_id.to_string(), @@ -2067,10 +2063,10 @@ impl<'a, C, NC, A> PeopleMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct MomentInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MomentInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Plus, + hub: &'a Plus, _request: Moment, _user_id: String, _collection: String, @@ -2080,9 +2076,9 @@ pub struct MomentInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MomentInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MomentInsertCall<'a, C, A> {} -impl<'a, C, NC, A> MomentInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MomentInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2225,7 +2221,7 @@ impl<'a, C, NC, A> MomentInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Moment) -> MomentInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Moment) -> MomentInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2235,7 +2231,7 @@ impl<'a, C, NC, A> MomentInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the user to record actions for. The only valid values are "me" and the ID of the authenticated user. - pub fn user_id(mut self, new_value: &str) -> MomentInsertCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> MomentInsertCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -2245,7 +2241,7 @@ impl<'a, C, NC, A> MomentInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The collection to which to write moments. - pub fn collection(mut self, new_value: &str) -> MomentInsertCall<'a, C, NC, A> { + pub fn collection(mut self, new_value: &str) -> MomentInsertCall<'a, C, A> { self._collection = new_value.to_string(); self } @@ -2253,7 +2249,7 @@ impl<'a, C, NC, A> MomentInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Return the moment as written. Should be used only for debugging. - pub fn debug(mut self, new_value: bool) -> MomentInsertCall<'a, C, NC, A> { + pub fn debug(mut self, new_value: bool) -> MomentInsertCall<'a, C, A> { self._debug = Some(new_value); self } @@ -2264,7 +2260,7 @@ impl<'a, C, NC, A> MomentInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MomentInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MomentInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2285,7 +2281,7 @@ impl<'a, C, NC, A> MomentInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MomentInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MomentInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2302,7 +2298,7 @@ impl<'a, C, NC, A> MomentInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MomentInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MomentInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2344,10 +2340,10 @@ impl<'a, C, NC, A> MomentInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct MomentListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MomentListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Plus, + hub: &'a Plus, _user_id: String, _collection: String, _type_: Option, @@ -2359,9 +2355,9 @@ pub struct MomentListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MomentListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MomentListCall<'a, C, A> {} -impl<'a, C, NC, A> MomentListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MomentListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2506,7 +2502,7 @@ impl<'a, C, NC, A> MomentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the user to get moments for. The special value "me" can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> MomentListCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> MomentListCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -2516,7 +2512,7 @@ impl<'a, C, NC, A> MomentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The collection of moments to list. - pub fn collection(mut self, new_value: &str) -> MomentListCall<'a, C, NC, A> { + pub fn collection(mut self, new_value: &str) -> MomentListCall<'a, C, A> { self._collection = new_value.to_string(); self } @@ -2524,7 +2520,7 @@ impl<'a, C, NC, A> MomentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Only moments of this type will be returned. - pub fn type_(mut self, new_value: &str) -> MomentListCall<'a, C, NC, A> { + pub fn type_(mut self, new_value: &str) -> MomentListCall<'a, C, A> { self._type_ = Some(new_value.to_string()); self } @@ -2532,7 +2528,7 @@ impl<'a, C, NC, A> MomentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Only moments containing this targetUrl will be returned. - pub fn target_url(mut self, new_value: &str) -> MomentListCall<'a, C, NC, A> { + pub fn target_url(mut self, new_value: &str) -> MomentListCall<'a, C, A> { self._target_url = Some(new_value.to_string()); self } @@ -2540,7 +2536,7 @@ impl<'a, C, NC, A> MomentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The continuation token, which is used to page through large result sets. To get the next page of results, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> MomentListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> MomentListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2548,7 +2544,7 @@ impl<'a, C, NC, A> MomentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The maximum number of moments to include in the response, which is used for paging. For any response, the actual number returned might be less than the specified maxResults. - pub fn max_results(mut self, new_value: u32) -> MomentListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> MomentListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2559,7 +2555,7 @@ impl<'a, C, NC, A> MomentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MomentListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MomentListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2580,7 +2576,7 @@ impl<'a, C, NC, A> MomentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MomentListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MomentListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2597,7 +2593,7 @@ impl<'a, C, NC, A> MomentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MomentListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MomentListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2635,19 +2631,19 @@ impl<'a, C, NC, A> MomentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct MomentRemoveCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MomentRemoveCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Plus, + hub: &'a Plus, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MomentRemoveCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MomentRemoveCall<'a, C, A> {} -impl<'a, C, NC, A> MomentRemoveCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MomentRemoveCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2768,7 +2764,7 @@ impl<'a, C, NC, A> MomentRemoveCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the moment to delete. - pub fn id(mut self, new_value: &str) -> MomentRemoveCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> MomentRemoveCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -2779,7 +2775,7 @@ impl<'a, C, NC, A> MomentRemoveCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MomentRemoveCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MomentRemoveCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2800,7 +2796,7 @@ impl<'a, C, NC, A> MomentRemoveCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MomentRemoveCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MomentRemoveCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2817,7 +2813,7 @@ impl<'a, C, NC, A> MomentRemoveCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MomentRemoveCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MomentRemoveCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2859,10 +2855,10 @@ impl<'a, C, NC, A> MomentRemoveCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct ActivitySearchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ActivitySearchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Plus, + hub: &'a Plus, _query: String, _page_token: Option, _order_by: Option, @@ -2873,9 +2869,9 @@ pub struct ActivitySearchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ActivitySearchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ActivitySearchCall<'a, C, A> {} -impl<'a, C, NC, A> ActivitySearchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ActivitySearchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2995,7 +2991,7 @@ impl<'a, C, NC, A> ActivitySearchCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Full-text search query string. - pub fn query(mut self, new_value: &str) -> ActivitySearchCall<'a, C, NC, A> { + pub fn query(mut self, new_value: &str) -> ActivitySearchCall<'a, C, A> { self._query = new_value.to_string(); self } @@ -3003,7 +2999,7 @@ impl<'a, C, NC, A> ActivitySearchCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The continuation token, which is used to page through large result sets. To get the next page of results, set this parameter to the value of "nextPageToken" from the previous response. This token can be of any length. - pub fn page_token(mut self, new_value: &str) -> ActivitySearchCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ActivitySearchCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -3011,7 +3007,7 @@ impl<'a, C, NC, A> ActivitySearchCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Specifies how to order search results. - pub fn order_by(mut self, new_value: &str) -> ActivitySearchCall<'a, C, NC, A> { + pub fn order_by(mut self, new_value: &str) -> ActivitySearchCall<'a, C, A> { self._order_by = Some(new_value.to_string()); self } @@ -3019,7 +3015,7 @@ impl<'a, C, NC, A> ActivitySearchCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The maximum number of activities to include in the response, which is used for paging. For any response, the actual number returned might be less than the specified maxResults. - pub fn max_results(mut self, new_value: u32) -> ActivitySearchCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> ActivitySearchCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -3027,7 +3023,7 @@ impl<'a, C, NC, A> ActivitySearchCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Specify the preferred language to search with. See search language codes for available values. - pub fn language(mut self, new_value: &str) -> ActivitySearchCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> ActivitySearchCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -3038,7 +3034,7 @@ impl<'a, C, NC, A> ActivitySearchCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivitySearchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivitySearchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3059,7 +3055,7 @@ impl<'a, C, NC, A> ActivitySearchCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ActivitySearchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ActivitySearchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3076,7 +3072,7 @@ impl<'a, C, NC, A> ActivitySearchCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ActivitySearchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ActivitySearchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3114,19 +3110,19 @@ impl<'a, C, NC, A> ActivitySearchCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct ActivityGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ActivityGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Plus, + hub: &'a Plus, _activity_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ActivityGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ActivityGetCall<'a, C, A> {} -impl<'a, C, NC, A> ActivityGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ActivityGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3258,7 +3254,7 @@ impl<'a, C, NC, A> ActivityGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the activity to get. - pub fn activity_id(mut self, new_value: &str) -> ActivityGetCall<'a, C, NC, A> { + pub fn activity_id(mut self, new_value: &str) -> ActivityGetCall<'a, C, A> { self._activity_id = new_value.to_string(); self } @@ -3269,7 +3265,7 @@ impl<'a, C, NC, A> ActivityGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivityGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivityGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3290,7 +3286,7 @@ impl<'a, C, NC, A> ActivityGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ActivityGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ActivityGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3307,7 +3303,7 @@ impl<'a, C, NC, A> ActivityGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ActivityGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ActivityGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3347,10 +3343,10 @@ impl<'a, C, NC, A> ActivityGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct ActivityListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ActivityListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Plus, + hub: &'a Plus, _user_id: String, _collection: String, _page_token: Option, @@ -3360,9 +3356,9 @@ pub struct ActivityListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ActivityListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ActivityListCall<'a, C, A> {} -impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ActivityListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3501,7 +3497,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the user to get activities for. The special value "me" can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -3511,7 +3507,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The collection of activities to list. - pub fn collection(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn collection(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._collection = new_value.to_string(); self } @@ -3519,7 +3515,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The continuation token, which is used to page through large result sets. To get the next page of results, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -3527,7 +3523,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The maximum number of activities to include in the response, which is used for paging. For any response, the actual number returned might be less than the specified maxResults. - pub fn max_results(mut self, new_value: u32) -> ActivityListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> ActivityListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -3538,7 +3534,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivityListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivityListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3559,7 +3555,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ActivityListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ActivityListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3576,7 +3572,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ActivityListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ActivityListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3617,10 +3613,10 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct CommentListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CommentListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Plus, + hub: &'a Plus, _activity_id: String, _sort_order: Option, _page_token: Option, @@ -3630,9 +3626,9 @@ pub struct CommentListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CommentListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CommentListCall<'a, C, A> {} -impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CommentListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3773,7 +3769,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the activity to get comments for. - pub fn activity_id(mut self, new_value: &str) -> CommentListCall<'a, C, NC, A> { + pub fn activity_id(mut self, new_value: &str) -> CommentListCall<'a, C, A> { self._activity_id = new_value.to_string(); self } @@ -3781,7 +3777,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The order in which to sort the list of comments. - pub fn sort_order(mut self, new_value: &str) -> CommentListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> CommentListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -3789,7 +3785,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The continuation token, which is used to page through large result sets. To get the next page of results, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> CommentListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> CommentListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -3797,7 +3793,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The maximum number of comments to include in the response, which is used for paging. For any response, the actual number returned might be less than the specified maxResults. - pub fn max_results(mut self, new_value: u32) -> CommentListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> CommentListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -3808,7 +3804,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3829,7 +3825,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CommentListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CommentListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3846,7 +3842,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CommentListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CommentListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3884,19 +3880,19 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct CommentGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CommentGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Plus, + hub: &'a Plus, _comment_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CommentGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CommentGetCall<'a, C, A> {} -impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CommentGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4028,7 +4024,7 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the comment to get. - pub fn comment_id(mut self, new_value: &str) -> CommentGetCall<'a, C, NC, A> { + pub fn comment_id(mut self, new_value: &str) -> CommentGetCall<'a, C, A> { self._comment_id = new_value.to_string(); self } @@ -4039,7 +4035,7 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4060,7 +4056,7 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CommentGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CommentGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4077,7 +4073,7 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CommentGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CommentGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4118,10 +4114,10 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct PeopleSearchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PeopleSearchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Plus, + hub: &'a Plus, _query: String, _page_token: Option, _max_results: Option, @@ -4131,9 +4127,9 @@ pub struct PeopleSearchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PeopleSearchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PeopleSearchCall<'a, C, A> {} -impl<'a, C, NC, A> PeopleSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PeopleSearchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4250,7 +4246,7 @@ impl<'a, C, NC, A> PeopleSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Specify a query string for full text search of public text in all profiles. - pub fn query(mut self, new_value: &str) -> PeopleSearchCall<'a, C, NC, A> { + pub fn query(mut self, new_value: &str) -> PeopleSearchCall<'a, C, A> { self._query = new_value.to_string(); self } @@ -4258,7 +4254,7 @@ impl<'a, C, NC, A> PeopleSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The continuation token, which is used to page through large result sets. To get the next page of results, set this parameter to the value of "nextPageToken" from the previous response. This token can be of any length. - pub fn page_token(mut self, new_value: &str) -> PeopleSearchCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> PeopleSearchCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -4266,7 +4262,7 @@ impl<'a, C, NC, A> PeopleSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The maximum number of people to include in the response, which is used for paging. For any response, the actual number returned might be less than the specified maxResults. - pub fn max_results(mut self, new_value: u32) -> PeopleSearchCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> PeopleSearchCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -4274,7 +4270,7 @@ impl<'a, C, NC, A> PeopleSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Specify the preferred language to search with. See search language codes for available values. - pub fn language(mut self, new_value: &str) -> PeopleSearchCall<'a, C, NC, A> { + pub fn language(mut self, new_value: &str) -> PeopleSearchCall<'a, C, A> { self._language = Some(new_value.to_string()); self } @@ -4285,7 +4281,7 @@ impl<'a, C, NC, A> PeopleSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PeopleSearchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PeopleSearchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4306,7 +4302,7 @@ impl<'a, C, NC, A> PeopleSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PeopleSearchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PeopleSearchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4323,7 +4319,7 @@ impl<'a, C, NC, A> PeopleSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PeopleSearchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PeopleSearchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4363,10 +4359,10 @@ impl<'a, C, NC, A> PeopleSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct PeopleListByActivityCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PeopleListByActivityCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Plus, + hub: &'a Plus, _activity_id: String, _collection: String, _page_token: Option, @@ -4376,9 +4372,9 @@ pub struct PeopleListByActivityCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PeopleListByActivityCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PeopleListByActivityCall<'a, C, A> {} -impl<'a, C, NC, A> PeopleListByActivityCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PeopleListByActivityCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4517,7 +4513,7 @@ impl<'a, C, NC, A> PeopleListByActivityCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The ID of the activity to get the list of people for. - pub fn activity_id(mut self, new_value: &str) -> PeopleListByActivityCall<'a, C, NC, A> { + pub fn activity_id(mut self, new_value: &str) -> PeopleListByActivityCall<'a, C, A> { self._activity_id = new_value.to_string(); self } @@ -4527,7 +4523,7 @@ impl<'a, C, NC, A> PeopleListByActivityCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The collection of people to list. - pub fn collection(mut self, new_value: &str) -> PeopleListByActivityCall<'a, C, NC, A> { + pub fn collection(mut self, new_value: &str) -> PeopleListByActivityCall<'a, C, A> { self._collection = new_value.to_string(); self } @@ -4535,7 +4531,7 @@ impl<'a, C, NC, A> PeopleListByActivityCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// The continuation token, which is used to page through large result sets. To get the next page of results, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> PeopleListByActivityCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> PeopleListByActivityCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -4543,7 +4539,7 @@ impl<'a, C, NC, A> PeopleListByActivityCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// The maximum number of people to include in the response, which is used for paging. For any response, the actual number returned might be less than the specified maxResults. - pub fn max_results(mut self, new_value: u32) -> PeopleListByActivityCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> PeopleListByActivityCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -4554,7 +4550,7 @@ impl<'a, C, NC, A> PeopleListByActivityCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PeopleListByActivityCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PeopleListByActivityCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4575,7 +4571,7 @@ impl<'a, C, NC, A> PeopleListByActivityCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PeopleListByActivityCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PeopleListByActivityCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4592,7 +4588,7 @@ impl<'a, C, NC, A> PeopleListByActivityCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PeopleListByActivityCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PeopleListByActivityCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4633,10 +4629,10 @@ impl<'a, C, NC, A> PeopleListByActivityCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct PeopleListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PeopleListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Plus, + hub: &'a Plus, _user_id: String, _collection: String, _page_token: Option, @@ -4647,9 +4643,9 @@ pub struct PeopleListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PeopleListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PeopleListCall<'a, C, A> {} -impl<'a, C, NC, A> PeopleListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PeopleListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4791,7 +4787,7 @@ impl<'a, C, NC, A> PeopleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Get the collection of people for the person identified. Use "me" to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> PeopleListCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> PeopleListCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -4801,7 +4797,7 @@ impl<'a, C, NC, A> PeopleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The collection of people to list. - pub fn collection(mut self, new_value: &str) -> PeopleListCall<'a, C, NC, A> { + pub fn collection(mut self, new_value: &str) -> PeopleListCall<'a, C, A> { self._collection = new_value.to_string(); self } @@ -4809,7 +4805,7 @@ impl<'a, C, NC, A> PeopleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The continuation token, which is used to page through large result sets. To get the next page of results, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> PeopleListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> PeopleListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -4817,7 +4813,7 @@ impl<'a, C, NC, A> PeopleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The order to return people in. - pub fn order_by(mut self, new_value: &str) -> PeopleListCall<'a, C, NC, A> { + pub fn order_by(mut self, new_value: &str) -> PeopleListCall<'a, C, A> { self._order_by = Some(new_value.to_string()); self } @@ -4825,7 +4821,7 @@ impl<'a, C, NC, A> PeopleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The maximum number of people to include in the response, which is used for paging. For any response, the actual number returned might be less than the specified maxResults. - pub fn max_results(mut self, new_value: u32) -> PeopleListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> PeopleListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -4836,7 +4832,7 @@ impl<'a, C, NC, A> PeopleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PeopleListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PeopleListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4857,7 +4853,7 @@ impl<'a, C, NC, A> PeopleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PeopleListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PeopleListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4874,7 +4870,7 @@ impl<'a, C, NC, A> PeopleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PeopleListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PeopleListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4912,19 +4908,19 @@ impl<'a, C, NC, A> PeopleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct PeopleGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PeopleGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Plus, + hub: &'a Plus, _user_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PeopleGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PeopleGetCall<'a, C, A> {} -impl<'a, C, NC, A> PeopleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PeopleGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5056,7 +5052,7 @@ impl<'a, C, NC, A> PeopleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the person to get the profile for. The special value "me" can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> PeopleGetCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> PeopleGetCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -5067,7 +5063,7 @@ impl<'a, C, NC, A> PeopleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PeopleGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PeopleGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5088,7 +5084,7 @@ impl<'a, C, NC, A> PeopleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PeopleGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PeopleGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5105,7 +5101,7 @@ impl<'a, C, NC, A> PeopleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PeopleGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PeopleGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/plusdomains1/Cargo.toml b/gen/plusdomains1/Cargo.toml index a1989f34fa6..f2d5cf2a8a6 100644 --- a/gen/plusdomains1/Cargo.toml +++ b/gen/plusdomains1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-plusdomains1" -version = "0.1.4+20150326" +version = "0.1.5+20150326" authors = ["Sebastian Thiel "] description = "A complete library to interact with plusDomains (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/plusdomains1" homepage = "https://developers.google.com/+/domains/" -documentation = "http://byron.github.io/google-apis-rs/google-plusdomains1" +documentation = "http://byron.github.io/google-apis-rs/google_plusdomains1" license = "MIT" keywords = ["plusDomains", "google", "protocol", "web", "api"] diff --git a/gen/plusdomains1/README.md b/gen/plusdomains1/README.md index b9711e6f9ea..d3d842214d3 100644 --- a/gen/plusdomains1/README.md +++ b/gen/plusdomains1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-plusdomains1` library allows access to all features of the *Google plusDomains* service. -This documentation was generated from *plusDomains* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *plusDomains:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *plusDomains* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *plusDomains:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *plusDomains* *v1* API can be found at the [official documentation site](https://developers.google.com/+/domains/). diff --git a/gen/plusdomains1/src/cmn.rs b/gen/plusdomains1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/plusdomains1/src/cmn.rs +++ b/gen/plusdomains1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/plusdomains1/src/lib.rs b/gen/plusdomains1/src/lib.rs index 1d620c1b218..8006d721380 100644 --- a/gen/plusdomains1/src/lib.rs +++ b/gen/plusdomains1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *plusDomains* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *plusDomains:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *plusDomains* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *plusDomains:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *plusDomains* *v1* API can be found at the //! [official documentation site](https://developers.google.com/+/domains/). @@ -211,7 +211,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -340,49 +339,46 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct PlusDomains { +pub struct PlusDomains { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for PlusDomains {} +impl<'a, C, A> Hub for PlusDomains {} -impl<'a, C, NC, A> PlusDomains - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlusDomains + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> PlusDomains { + pub fn new(client: C, authenticator: A) -> PlusDomains { PlusDomains { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn activities(&'a self) -> ActivityMethods<'a, C, NC, A> { + pub fn activities(&'a self) -> ActivityMethods<'a, C, A> { ActivityMethods { hub: &self } } - pub fn audiences(&'a self) -> AudienceMethods<'a, C, NC, A> { + pub fn audiences(&'a self) -> AudienceMethods<'a, C, A> { AudienceMethods { hub: &self } } - pub fn circles(&'a self) -> CircleMethods<'a, C, NC, A> { + pub fn circles(&'a self) -> CircleMethods<'a, C, A> { CircleMethods { hub: &self } } - pub fn comments(&'a self) -> CommentMethods<'a, C, NC, A> { + pub fn comments(&'a self) -> CommentMethods<'a, C, A> { CommentMethods { hub: &self } } - pub fn media(&'a self) -> MediaMethods<'a, C, NC, A> { + pub fn media(&'a self) -> MediaMethods<'a, C, A> { MediaMethods { hub: &self } } - pub fn people(&'a self) -> PeopleMethods<'a, C, NC, A> { + pub fn people(&'a self) -> PeopleMethods<'a, C, A> { PeopleMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -1780,15 +1776,15 @@ impl ResponseResult for CircleFeed {} /// let rb = hub.circles(); /// # } /// ``` -pub struct CircleMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CircleMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, } -impl<'a, C, NC, A> MethodsBuilder for CircleMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CircleMethods<'a, C, A> {} -impl<'a, C, NC, A> CircleMethods<'a, C, NC, A> { +impl<'a, C, A> CircleMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1797,7 +1793,7 @@ impl<'a, C, NC, A> CircleMethods<'a, C, NC, A> { /// # Arguments /// /// * `circleId` - The ID of the circle to remove the person from. - pub fn remove_people(&self, circle_id: &str) -> CircleRemovePeopleCall<'a, C, NC, A> { + pub fn remove_people(&self, circle_id: &str) -> CircleRemovePeopleCall<'a, C, A> { CircleRemovePeopleCall { hub: self.hub, _circle_id: circle_id.to_string(), @@ -1817,7 +1813,7 @@ impl<'a, C, NC, A> CircleMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `userId` - The ID of the user to create the circle on behalf of. The value "me" can be used to indicate the authenticated user. - pub fn insert(&self, request: &Circle, user_id: &str) -> CircleInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Circle, user_id: &str) -> CircleInsertCall<'a, C, A> { CircleInsertCall { hub: self.hub, _request: request.clone(), @@ -1835,7 +1831,7 @@ impl<'a, C, NC, A> CircleMethods<'a, C, NC, A> { /// # Arguments /// /// * `circleId` - The ID of the circle to add the person to. - pub fn add_people(&self, circle_id: &str) -> CircleAddPeopleCall<'a, C, NC, A> { + pub fn add_people(&self, circle_id: &str) -> CircleAddPeopleCall<'a, C, A> { CircleAddPeopleCall { hub: self.hub, _circle_id: circle_id.to_string(), @@ -1854,7 +1850,7 @@ impl<'a, C, NC, A> CircleMethods<'a, C, NC, A> { /// # Arguments /// /// * `circleId` - The ID of the circle to get. - pub fn get(&self, circle_id: &str) -> CircleGetCall<'a, C, NC, A> { + pub fn get(&self, circle_id: &str) -> CircleGetCall<'a, C, A> { CircleGetCall { hub: self.hub, _circle_id: circle_id.to_string(), @@ -1871,7 +1867,7 @@ impl<'a, C, NC, A> CircleMethods<'a, C, NC, A> { /// # Arguments /// /// * `userId` - The ID of the user to get circles for. The special value "me" can be used to indicate the authenticated user. - pub fn list(&self, user_id: &str) -> CircleListCall<'a, C, NC, A> { + pub fn list(&self, user_id: &str) -> CircleListCall<'a, C, A> { CircleListCall { hub: self.hub, _user_id: user_id.to_string(), @@ -1891,7 +1887,7 @@ impl<'a, C, NC, A> CircleMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `circleId` - The ID of the circle to update. - pub fn update(&self, request: &Circle, circle_id: &str) -> CircleUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Circle, circle_id: &str) -> CircleUpdateCall<'a, C, A> { CircleUpdateCall { hub: self.hub, _request: request.clone(), @@ -1910,7 +1906,7 @@ impl<'a, C, NC, A> CircleMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `circleId` - The ID of the circle to update. - pub fn patch(&self, request: &Circle, circle_id: &str) -> CirclePatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Circle, circle_id: &str) -> CirclePatchCall<'a, C, A> { CirclePatchCall { hub: self.hub, _request: request.clone(), @@ -1928,7 +1924,7 @@ impl<'a, C, NC, A> CircleMethods<'a, C, NC, A> { /// # Arguments /// /// * `circleId` - The ID of the circle to delete. - pub fn remove(&self, circle_id: &str) -> CircleRemoveCall<'a, C, NC, A> { + pub fn remove(&self, circle_id: &str) -> CircleRemoveCall<'a, C, A> { CircleRemoveCall { hub: self.hub, _circle_id: circle_id.to_string(), @@ -1969,15 +1965,15 @@ impl<'a, C, NC, A> CircleMethods<'a, C, NC, A> { /// let rb = hub.activities(); /// # } /// ``` -pub struct ActivityMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ActivityMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, } -impl<'a, C, NC, A> MethodsBuilder for ActivityMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ActivityMethods<'a, C, A> {} -impl<'a, C, NC, A> ActivityMethods<'a, C, NC, A> { +impl<'a, C, A> ActivityMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1987,7 +1983,7 @@ impl<'a, C, NC, A> ActivityMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `userId` - The ID of the user to create the activity on behalf of. Its value should be "me", to indicate the authenticated user. - pub fn insert(&self, request: &Activity, user_id: &str) -> ActivityInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Activity, user_id: &str) -> ActivityInsertCall<'a, C, A> { ActivityInsertCall { hub: self.hub, _request: request.clone(), @@ -2006,7 +2002,7 @@ impl<'a, C, NC, A> ActivityMethods<'a, C, NC, A> { /// # Arguments /// /// * `activityId` - The ID of the activity to get. - pub fn get(&self, activity_id: &str) -> ActivityGetCall<'a, C, NC, A> { + pub fn get(&self, activity_id: &str) -> ActivityGetCall<'a, C, A> { ActivityGetCall { hub: self.hub, _activity_id: activity_id.to_string(), @@ -2024,7 +2020,7 @@ impl<'a, C, NC, A> ActivityMethods<'a, C, NC, A> { /// /// * `userId` - The ID of the user to get activities for. The special value "me" can be used to indicate the authenticated user. /// * `collection` - The collection of activities to list. - pub fn list(&self, user_id: &str, collection: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn list(&self, user_id: &str, collection: &str) -> ActivityListCall<'a, C, A> { ActivityListCall { hub: self.hub, _user_id: user_id.to_string(), @@ -2068,15 +2064,15 @@ impl<'a, C, NC, A> ActivityMethods<'a, C, NC, A> { /// let rb = hub.people(); /// # } /// ``` -pub struct PeopleMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PeopleMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, } -impl<'a, C, NC, A> MethodsBuilder for PeopleMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PeopleMethods<'a, C, A> {} -impl<'a, C, NC, A> PeopleMethods<'a, C, NC, A> { +impl<'a, C, A> PeopleMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2085,7 +2081,7 @@ impl<'a, C, NC, A> PeopleMethods<'a, C, NC, A> { /// # Arguments /// /// * `circleId` - The ID of the circle to get the members of. - pub fn list_by_circle(&self, circle_id: &str) -> PeopleListByCircleCall<'a, C, NC, A> { + pub fn list_by_circle(&self, circle_id: &str) -> PeopleListByCircleCall<'a, C, A> { PeopleListByCircleCall { hub: self.hub, _circle_id: circle_id.to_string(), @@ -2105,7 +2101,7 @@ impl<'a, C, NC, A> PeopleMethods<'a, C, NC, A> { /// /// * `userId` - Get the collection of people for the person identified. Use "me" to indicate the authenticated user. /// * `collection` - The collection of people to list. - pub fn list(&self, user_id: &str, collection: &str) -> PeopleListCall<'a, C, NC, A> { + pub fn list(&self, user_id: &str, collection: &str) -> PeopleListCall<'a, C, A> { PeopleListCall { hub: self.hub, _user_id: user_id.to_string(), @@ -2126,7 +2122,7 @@ impl<'a, C, NC, A> PeopleMethods<'a, C, NC, A> { /// # Arguments /// /// * `userId` - The ID of the person to get the profile for. The special value "me" can be used to indicate the authenticated user. - pub fn get(&self, user_id: &str) -> PeopleGetCall<'a, C, NC, A> { + pub fn get(&self, user_id: &str) -> PeopleGetCall<'a, C, A> { PeopleGetCall { hub: self.hub, _user_id: user_id.to_string(), @@ -2144,7 +2140,7 @@ impl<'a, C, NC, A> PeopleMethods<'a, C, NC, A> { /// /// * `activityId` - The ID of the activity to get the list of people for. /// * `collection` - The collection of people to list. - pub fn list_by_activity(&self, activity_id: &str, collection: &str) -> PeopleListByActivityCall<'a, C, NC, A> { + pub fn list_by_activity(&self, activity_id: &str, collection: &str) -> PeopleListByActivityCall<'a, C, A> { PeopleListByActivityCall { hub: self.hub, _activity_id: activity_id.to_string(), @@ -2188,15 +2184,15 @@ impl<'a, C, NC, A> PeopleMethods<'a, C, NC, A> { /// let rb = hub.media(); /// # } /// ``` -pub struct MediaMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MediaMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, } -impl<'a, C, NC, A> MethodsBuilder for MediaMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for MediaMethods<'a, C, A> {} -impl<'a, C, NC, A> MediaMethods<'a, C, NC, A> { +impl<'a, C, A> MediaMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2207,7 +2203,7 @@ impl<'a, C, NC, A> MediaMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `userId` - The ID of the user to create the activity on behalf of. /// * `collection` - No description provided. - pub fn insert(&self, request: &Media, user_id: &str, collection: &str) -> MediaInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Media, user_id: &str, collection: &str) -> MediaInsertCall<'a, C, A> { MediaInsertCall { hub: self.hub, _request: request.clone(), @@ -2250,15 +2246,15 @@ impl<'a, C, NC, A> MediaMethods<'a, C, NC, A> { /// let rb = hub.comments(); /// # } /// ``` -pub struct CommentMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CommentMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, } -impl<'a, C, NC, A> MethodsBuilder for CommentMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CommentMethods<'a, C, A> {} -impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { +impl<'a, C, A> CommentMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2268,7 +2264,7 @@ impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `activityId` - The ID of the activity to reply to. - pub fn insert(&self, request: &Comment, activity_id: &str) -> CommentInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Comment, activity_id: &str) -> CommentInsertCall<'a, C, A> { CommentInsertCall { hub: self.hub, _request: request.clone(), @@ -2286,7 +2282,7 @@ impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { /// # Arguments /// /// * `activityId` - The ID of the activity to get comments for. - pub fn list(&self, activity_id: &str) -> CommentListCall<'a, C, NC, A> { + pub fn list(&self, activity_id: &str) -> CommentListCall<'a, C, A> { CommentListCall { hub: self.hub, _activity_id: activity_id.to_string(), @@ -2306,7 +2302,7 @@ impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { /// # Arguments /// /// * `commentId` - The ID of the comment to get. - pub fn get(&self, comment_id: &str) -> CommentGetCall<'a, C, NC, A> { + pub fn get(&self, comment_id: &str) -> CommentGetCall<'a, C, A> { CommentGetCall { hub: self.hub, _comment_id: comment_id.to_string(), @@ -2347,15 +2343,15 @@ impl<'a, C, NC, A> CommentMethods<'a, C, NC, A> { /// let rb = hub.audiences(); /// # } /// ``` -pub struct AudienceMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AudienceMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, } -impl<'a, C, NC, A> MethodsBuilder for AudienceMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AudienceMethods<'a, C, A> {} -impl<'a, C, NC, A> AudienceMethods<'a, C, NC, A> { +impl<'a, C, A> AudienceMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2364,7 +2360,7 @@ impl<'a, C, NC, A> AudienceMethods<'a, C, NC, A> { /// # Arguments /// /// * `userId` - The ID of the user to get audiences for. The special value "me" can be used to indicate the authenticated user. - pub fn list(&self, user_id: &str) -> AudienceListCall<'a, C, NC, A> { + pub fn list(&self, user_id: &str) -> AudienceListCall<'a, C, A> { AudienceListCall { hub: self.hub, _user_id: user_id.to_string(), @@ -2417,10 +2413,10 @@ impl<'a, C, NC, A> AudienceMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct CircleRemovePeopleCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CircleRemovePeopleCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, _circle_id: String, _user_id: Vec, _email: Vec, @@ -2429,9 +2425,9 @@ pub struct CircleRemovePeopleCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CircleRemovePeopleCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CircleRemovePeopleCall<'a, C, A> {} -impl<'a, C, NC, A> CircleRemovePeopleCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CircleRemovePeopleCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2566,7 +2562,7 @@ impl<'a, C, NC, A> CircleRemovePeopleCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The ID of the circle to remove the person from. - pub fn circle_id(mut self, new_value: &str) -> CircleRemovePeopleCall<'a, C, NC, A> { + pub fn circle_id(mut self, new_value: &str) -> CircleRemovePeopleCall<'a, C, A> { self._circle_id = new_value.to_string(); self } @@ -2575,7 +2571,7 @@ impl<'a, C, NC, A> CircleRemovePeopleCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// IDs of the people to remove from the circle. Optional, can be repeated. - pub fn add_user_id(mut self, new_value: &str) -> CircleRemovePeopleCall<'a, C, NC, A> { + pub fn add_user_id(mut self, new_value: &str) -> CircleRemovePeopleCall<'a, C, A> { self._user_id.push(new_value.to_string()); self } @@ -2584,7 +2580,7 @@ impl<'a, C, NC, A> CircleRemovePeopleCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Email of the people to add to the circle. Optional, can be repeated. - pub fn add_email(mut self, new_value: &str) -> CircleRemovePeopleCall<'a, C, NC, A> { + pub fn add_email(mut self, new_value: &str) -> CircleRemovePeopleCall<'a, C, A> { self._email.push(new_value.to_string()); self } @@ -2595,7 +2591,7 @@ impl<'a, C, NC, A> CircleRemovePeopleCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CircleRemovePeopleCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CircleRemovePeopleCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2616,7 +2612,7 @@ impl<'a, C, NC, A> CircleRemovePeopleCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CircleRemovePeopleCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CircleRemovePeopleCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2633,7 +2629,7 @@ impl<'a, C, NC, A> CircleRemovePeopleCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CircleRemovePeopleCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CircleRemovePeopleCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2677,10 +2673,10 @@ impl<'a, C, NC, A> CircleRemovePeopleCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct CircleInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CircleInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, _request: Circle, _user_id: String, _delegate: Option<&'a mut Delegate>, @@ -2688,9 +2684,9 @@ pub struct CircleInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CircleInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CircleInsertCall<'a, C, A> {} -impl<'a, C, NC, A> CircleInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CircleInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2829,7 +2825,7 @@ impl<'a, C, NC, A> CircleInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Circle) -> CircleInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Circle) -> CircleInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2839,7 +2835,7 @@ impl<'a, C, NC, A> CircleInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the user to create the circle on behalf of. The value "me" can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> CircleInsertCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> CircleInsertCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -2850,7 +2846,7 @@ impl<'a, C, NC, A> CircleInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CircleInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CircleInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2871,7 +2867,7 @@ impl<'a, C, NC, A> CircleInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CircleInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CircleInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2888,7 +2884,7 @@ impl<'a, C, NC, A> CircleInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CircleInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CircleInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2928,10 +2924,10 @@ impl<'a, C, NC, A> CircleInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct CircleAddPeopleCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CircleAddPeopleCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, _circle_id: String, _user_id: Vec, _email: Vec, @@ -2940,9 +2936,9 @@ pub struct CircleAddPeopleCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CircleAddPeopleCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CircleAddPeopleCall<'a, C, A> {} -impl<'a, C, NC, A> CircleAddPeopleCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CircleAddPeopleCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3088,7 +3084,7 @@ impl<'a, C, NC, A> CircleAddPeopleCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The ID of the circle to add the person to. - pub fn circle_id(mut self, new_value: &str) -> CircleAddPeopleCall<'a, C, NC, A> { + pub fn circle_id(mut self, new_value: &str) -> CircleAddPeopleCall<'a, C, A> { self._circle_id = new_value.to_string(); self } @@ -3097,7 +3093,7 @@ impl<'a, C, NC, A> CircleAddPeopleCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// IDs of the people to add to the circle. Optional, can be repeated. - pub fn add_user_id(mut self, new_value: &str) -> CircleAddPeopleCall<'a, C, NC, A> { + pub fn add_user_id(mut self, new_value: &str) -> CircleAddPeopleCall<'a, C, A> { self._user_id.push(new_value.to_string()); self } @@ -3106,7 +3102,7 @@ impl<'a, C, NC, A> CircleAddPeopleCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// Email of the people to add to the circle. Optional, can be repeated. - pub fn add_email(mut self, new_value: &str) -> CircleAddPeopleCall<'a, C, NC, A> { + pub fn add_email(mut self, new_value: &str) -> CircleAddPeopleCall<'a, C, A> { self._email.push(new_value.to_string()); self } @@ -3117,7 +3113,7 @@ impl<'a, C, NC, A> CircleAddPeopleCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CircleAddPeopleCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CircleAddPeopleCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3138,7 +3134,7 @@ impl<'a, C, NC, A> CircleAddPeopleCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CircleAddPeopleCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CircleAddPeopleCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3155,7 +3151,7 @@ impl<'a, C, NC, A> CircleAddPeopleCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CircleAddPeopleCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CircleAddPeopleCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3193,19 +3189,19 @@ impl<'a, C, NC, A> CircleAddPeopleCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct CircleGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CircleGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, _circle_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CircleGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CircleGetCall<'a, C, A> {} -impl<'a, C, NC, A> CircleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CircleGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3337,7 +3333,7 @@ impl<'a, C, NC, A> CircleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the circle to get. - pub fn circle_id(mut self, new_value: &str) -> CircleGetCall<'a, C, NC, A> { + pub fn circle_id(mut self, new_value: &str) -> CircleGetCall<'a, C, A> { self._circle_id = new_value.to_string(); self } @@ -3348,7 +3344,7 @@ impl<'a, C, NC, A> CircleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CircleGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CircleGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3369,7 +3365,7 @@ impl<'a, C, NC, A> CircleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CircleGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CircleGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3386,7 +3382,7 @@ impl<'a, C, NC, A> CircleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CircleGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CircleGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3426,10 +3422,10 @@ impl<'a, C, NC, A> CircleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct CircleListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CircleListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, _user_id: String, _page_token: Option, _max_results: Option, @@ -3438,9 +3434,9 @@ pub struct CircleListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CircleListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CircleListCall<'a, C, A> {} -impl<'a, C, NC, A> CircleListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CircleListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3578,7 +3574,7 @@ impl<'a, C, NC, A> CircleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the user to get circles for. The special value "me" can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> CircleListCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> CircleListCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -3586,7 +3582,7 @@ impl<'a, C, NC, A> CircleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The continuation token, which is used to page through large result sets. To get the next page of results, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> CircleListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> CircleListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -3594,7 +3590,7 @@ impl<'a, C, NC, A> CircleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The maximum number of circles to include in the response, which is used for paging. For any response, the actual number returned might be less than the specified maxResults. - pub fn max_results(mut self, new_value: u32) -> CircleListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> CircleListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -3605,7 +3601,7 @@ impl<'a, C, NC, A> CircleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CircleListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CircleListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3626,7 +3622,7 @@ impl<'a, C, NC, A> CircleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CircleListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CircleListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3643,7 +3639,7 @@ impl<'a, C, NC, A> CircleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CircleListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CircleListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3687,10 +3683,10 @@ impl<'a, C, NC, A> CircleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct CircleUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CircleUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, _request: Circle, _circle_id: String, _delegate: Option<&'a mut Delegate>, @@ -3698,9 +3694,9 @@ pub struct CircleUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CircleUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CircleUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> CircleUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CircleUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3839,7 +3835,7 @@ impl<'a, C, NC, A> CircleUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Circle) -> CircleUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Circle) -> CircleUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3849,7 +3845,7 @@ impl<'a, C, NC, A> CircleUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the circle to update. - pub fn circle_id(mut self, new_value: &str) -> CircleUpdateCall<'a, C, NC, A> { + pub fn circle_id(mut self, new_value: &str) -> CircleUpdateCall<'a, C, A> { self._circle_id = new_value.to_string(); self } @@ -3860,7 +3856,7 @@ impl<'a, C, NC, A> CircleUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CircleUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CircleUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3881,7 +3877,7 @@ impl<'a, C, NC, A> CircleUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CircleUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CircleUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3898,7 +3894,7 @@ impl<'a, C, NC, A> CircleUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CircleUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CircleUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3942,10 +3938,10 @@ impl<'a, C, NC, A> CircleUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct CirclePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CirclePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, _request: Circle, _circle_id: String, _delegate: Option<&'a mut Delegate>, @@ -3953,9 +3949,9 @@ pub struct CirclePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CirclePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CirclePatchCall<'a, C, A> {} -impl<'a, C, NC, A> CirclePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CirclePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4094,7 +4090,7 @@ impl<'a, C, NC, A> CirclePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Circle) -> CirclePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Circle) -> CirclePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4104,7 +4100,7 @@ impl<'a, C, NC, A> CirclePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the circle to update. - pub fn circle_id(mut self, new_value: &str) -> CirclePatchCall<'a, C, NC, A> { + pub fn circle_id(mut self, new_value: &str) -> CirclePatchCall<'a, C, A> { self._circle_id = new_value.to_string(); self } @@ -4115,7 +4111,7 @@ impl<'a, C, NC, A> CirclePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CirclePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CirclePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4136,7 +4132,7 @@ impl<'a, C, NC, A> CirclePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CirclePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CirclePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4153,7 +4149,7 @@ impl<'a, C, NC, A> CirclePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CirclePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CirclePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4191,19 +4187,19 @@ impl<'a, C, NC, A> CirclePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct CircleRemoveCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CircleRemoveCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, _circle_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CircleRemoveCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CircleRemoveCall<'a, C, A> {} -impl<'a, C, NC, A> CircleRemoveCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CircleRemoveCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4324,7 +4320,7 @@ impl<'a, C, NC, A> CircleRemoveCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the circle to delete. - pub fn circle_id(mut self, new_value: &str) -> CircleRemoveCall<'a, C, NC, A> { + pub fn circle_id(mut self, new_value: &str) -> CircleRemoveCall<'a, C, A> { self._circle_id = new_value.to_string(); self } @@ -4335,7 +4331,7 @@ impl<'a, C, NC, A> CircleRemoveCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CircleRemoveCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CircleRemoveCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4356,7 +4352,7 @@ impl<'a, C, NC, A> CircleRemoveCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CircleRemoveCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CircleRemoveCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4373,7 +4369,7 @@ impl<'a, C, NC, A> CircleRemoveCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CircleRemoveCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CircleRemoveCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4418,10 +4414,10 @@ impl<'a, C, NC, A> CircleRemoveCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct ActivityInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ActivityInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, _request: Activity, _user_id: String, _preview: Option, @@ -4430,9 +4426,9 @@ pub struct ActivityInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ActivityInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ActivityInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ActivityInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ActivityInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4574,7 +4570,7 @@ impl<'a, C, NC, A> ActivityInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Activity) -> ActivityInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Activity) -> ActivityInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4584,7 +4580,7 @@ impl<'a, C, NC, A> ActivityInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The ID of the user to create the activity on behalf of. Its value should be "me", to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> ActivityInsertCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> ActivityInsertCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -4592,7 +4588,7 @@ impl<'a, C, NC, A> ActivityInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// If "true", extract the potential media attachments for a URL. The response will include all possible attachments for a URL, including video, photos, and articles based on the content of the page. - pub fn preview(mut self, new_value: bool) -> ActivityInsertCall<'a, C, NC, A> { + pub fn preview(mut self, new_value: bool) -> ActivityInsertCall<'a, C, A> { self._preview = Some(new_value); self } @@ -4603,7 +4599,7 @@ impl<'a, C, NC, A> ActivityInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivityInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivityInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4624,7 +4620,7 @@ impl<'a, C, NC, A> ActivityInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ActivityInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ActivityInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4641,7 +4637,7 @@ impl<'a, C, NC, A> ActivityInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ActivityInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ActivityInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4679,19 +4675,19 @@ impl<'a, C, NC, A> ActivityInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct ActivityGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ActivityGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, _activity_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ActivityGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ActivityGetCall<'a, C, A> {} -impl<'a, C, NC, A> ActivityGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ActivityGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4823,7 +4819,7 @@ impl<'a, C, NC, A> ActivityGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the activity to get. - pub fn activity_id(mut self, new_value: &str) -> ActivityGetCall<'a, C, NC, A> { + pub fn activity_id(mut self, new_value: &str) -> ActivityGetCall<'a, C, A> { self._activity_id = new_value.to_string(); self } @@ -4834,7 +4830,7 @@ impl<'a, C, NC, A> ActivityGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivityGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivityGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4855,7 +4851,7 @@ impl<'a, C, NC, A> ActivityGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ActivityGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ActivityGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4872,7 +4868,7 @@ impl<'a, C, NC, A> ActivityGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ActivityGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ActivityGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4912,10 +4908,10 @@ impl<'a, C, NC, A> ActivityGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct ActivityListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ActivityListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, _user_id: String, _collection: String, _page_token: Option, @@ -4925,9 +4921,9 @@ pub struct ActivityListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ActivityListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ActivityListCall<'a, C, A> {} -impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ActivityListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5066,7 +5062,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the user to get activities for. The special value "me" can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -5076,7 +5072,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The collection of activities to list. - pub fn collection(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn collection(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._collection = new_value.to_string(); self } @@ -5084,7 +5080,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The continuation token, which is used to page through large result sets. To get the next page of results, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -5092,7 +5088,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The maximum number of activities to include in the response, which is used for paging. For any response, the actual number returned might be less than the specified maxResults. - pub fn max_results(mut self, new_value: u32) -> ActivityListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> ActivityListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -5103,7 +5099,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivityListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivityListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5124,7 +5120,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ActivityListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ActivityListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5141,7 +5137,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ActivityListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ActivityListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5181,10 +5177,10 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct PeopleListByCircleCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PeopleListByCircleCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, _circle_id: String, _page_token: Option, _max_results: Option, @@ -5193,9 +5189,9 @@ pub struct PeopleListByCircleCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PeopleListByCircleCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PeopleListByCircleCall<'a, C, A> {} -impl<'a, C, NC, A> PeopleListByCircleCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PeopleListByCircleCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5333,7 +5329,7 @@ impl<'a, C, NC, A> PeopleListByCircleCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The ID of the circle to get the members of. - pub fn circle_id(mut self, new_value: &str) -> PeopleListByCircleCall<'a, C, NC, A> { + pub fn circle_id(mut self, new_value: &str) -> PeopleListByCircleCall<'a, C, A> { self._circle_id = new_value.to_string(); self } @@ -5341,7 +5337,7 @@ impl<'a, C, NC, A> PeopleListByCircleCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// The continuation token, which is used to page through large result sets. To get the next page of results, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> PeopleListByCircleCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> PeopleListByCircleCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -5349,7 +5345,7 @@ impl<'a, C, NC, A> PeopleListByCircleCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// The maximum number of people to include in the response, which is used for paging. For any response, the actual number returned might be less than the specified maxResults. - pub fn max_results(mut self, new_value: u32) -> PeopleListByCircleCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> PeopleListByCircleCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -5360,7 +5356,7 @@ impl<'a, C, NC, A> PeopleListByCircleCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PeopleListByCircleCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PeopleListByCircleCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5381,7 +5377,7 @@ impl<'a, C, NC, A> PeopleListByCircleCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PeopleListByCircleCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PeopleListByCircleCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5398,7 +5394,7 @@ impl<'a, C, NC, A> PeopleListByCircleCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PeopleListByCircleCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PeopleListByCircleCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5439,10 +5435,10 @@ impl<'a, C, NC, A> PeopleListByCircleCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct PeopleListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PeopleListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, _user_id: String, _collection: String, _page_token: Option, @@ -5453,9 +5449,9 @@ pub struct PeopleListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PeopleListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PeopleListCall<'a, C, A> {} -impl<'a, C, NC, A> PeopleListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PeopleListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5597,7 +5593,7 @@ impl<'a, C, NC, A> PeopleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Get the collection of people for the person identified. Use "me" to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> PeopleListCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> PeopleListCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -5607,7 +5603,7 @@ impl<'a, C, NC, A> PeopleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The collection of people to list. - pub fn collection(mut self, new_value: &str) -> PeopleListCall<'a, C, NC, A> { + pub fn collection(mut self, new_value: &str) -> PeopleListCall<'a, C, A> { self._collection = new_value.to_string(); self } @@ -5615,7 +5611,7 @@ impl<'a, C, NC, A> PeopleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The continuation token, which is used to page through large result sets. To get the next page of results, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> PeopleListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> PeopleListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -5623,7 +5619,7 @@ impl<'a, C, NC, A> PeopleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The order to return people in. - pub fn order_by(mut self, new_value: &str) -> PeopleListCall<'a, C, NC, A> { + pub fn order_by(mut self, new_value: &str) -> PeopleListCall<'a, C, A> { self._order_by = Some(new_value.to_string()); self } @@ -5631,7 +5627,7 @@ impl<'a, C, NC, A> PeopleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The maximum number of people to include in the response, which is used for paging. For any response, the actual number returned might be less than the specified maxResults. - pub fn max_results(mut self, new_value: u32) -> PeopleListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> PeopleListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -5642,7 +5638,7 @@ impl<'a, C, NC, A> PeopleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PeopleListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PeopleListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5663,7 +5659,7 @@ impl<'a, C, NC, A> PeopleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PeopleListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PeopleListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5680,7 +5676,7 @@ impl<'a, C, NC, A> PeopleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PeopleListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PeopleListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5718,19 +5714,19 @@ impl<'a, C, NC, A> PeopleListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct PeopleGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PeopleGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, _user_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PeopleGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PeopleGetCall<'a, C, A> {} -impl<'a, C, NC, A> PeopleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PeopleGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5862,7 +5858,7 @@ impl<'a, C, NC, A> PeopleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The ID of the person to get the profile for. The special value "me" can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> PeopleGetCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> PeopleGetCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -5873,7 +5869,7 @@ impl<'a, C, NC, A> PeopleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PeopleGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PeopleGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5894,7 +5890,7 @@ impl<'a, C, NC, A> PeopleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PeopleGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PeopleGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5911,7 +5907,7 @@ impl<'a, C, NC, A> PeopleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PeopleGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PeopleGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5951,10 +5947,10 @@ impl<'a, C, NC, A> PeopleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct PeopleListByActivityCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PeopleListByActivityCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, _activity_id: String, _collection: String, _page_token: Option, @@ -5964,9 +5960,9 @@ pub struct PeopleListByActivityCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PeopleListByActivityCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PeopleListByActivityCall<'a, C, A> {} -impl<'a, C, NC, A> PeopleListByActivityCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PeopleListByActivityCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6105,7 +6101,7 @@ impl<'a, C, NC, A> PeopleListByActivityCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The ID of the activity to get the list of people for. - pub fn activity_id(mut self, new_value: &str) -> PeopleListByActivityCall<'a, C, NC, A> { + pub fn activity_id(mut self, new_value: &str) -> PeopleListByActivityCall<'a, C, A> { self._activity_id = new_value.to_string(); self } @@ -6115,7 +6111,7 @@ impl<'a, C, NC, A> PeopleListByActivityCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The collection of people to list. - pub fn collection(mut self, new_value: &str) -> PeopleListByActivityCall<'a, C, NC, A> { + pub fn collection(mut self, new_value: &str) -> PeopleListByActivityCall<'a, C, A> { self._collection = new_value.to_string(); self } @@ -6123,7 +6119,7 @@ impl<'a, C, NC, A> PeopleListByActivityCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// The continuation token, which is used to page through large result sets. To get the next page of results, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> PeopleListByActivityCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> PeopleListByActivityCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -6131,7 +6127,7 @@ impl<'a, C, NC, A> PeopleListByActivityCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// The maximum number of people to include in the response, which is used for paging. For any response, the actual number returned might be less than the specified maxResults. - pub fn max_results(mut self, new_value: u32) -> PeopleListByActivityCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> PeopleListByActivityCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -6142,7 +6138,7 @@ impl<'a, C, NC, A> PeopleListByActivityCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PeopleListByActivityCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PeopleListByActivityCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6163,7 +6159,7 @@ impl<'a, C, NC, A> PeopleListByActivityCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PeopleListByActivityCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PeopleListByActivityCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6180,7 +6176,7 @@ impl<'a, C, NC, A> PeopleListByActivityCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PeopleListByActivityCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PeopleListByActivityCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6225,10 +6221,10 @@ impl<'a, C, NC, A> PeopleListByActivityCall<'a, C, NC, A> where NC: hyper::net:: /// .upload(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct MediaInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct MediaInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, _request: Media, _user_id: String, _collection: String, @@ -6237,9 +6233,9 @@ pub struct MediaInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for MediaInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for MediaInsertCall<'a, C, A> {} -impl<'a, C, NC, A> MediaInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> MediaInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6489,7 +6485,7 @@ impl<'a, C, NC, A> MediaInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Media) -> MediaInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Media) -> MediaInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6499,7 +6495,7 @@ impl<'a, C, NC, A> MediaInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the user to create the activity on behalf of. - pub fn user_id(mut self, new_value: &str) -> MediaInsertCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> MediaInsertCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -6508,7 +6504,7 @@ impl<'a, C, NC, A> MediaInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn collection(mut self, new_value: &str) -> MediaInsertCall<'a, C, NC, A> { + pub fn collection(mut self, new_value: &str) -> MediaInsertCall<'a, C, A> { self._collection = new_value.to_string(); self } @@ -6519,7 +6515,7 @@ impl<'a, C, NC, A> MediaInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> MediaInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> MediaInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6540,7 +6536,7 @@ impl<'a, C, NC, A> MediaInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> MediaInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> MediaInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6557,7 +6553,7 @@ impl<'a, C, NC, A> MediaInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> MediaInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> MediaInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6601,10 +6597,10 @@ impl<'a, C, NC, A> MediaInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct CommentInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CommentInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, _request: Comment, _activity_id: String, _delegate: Option<&'a mut Delegate>, @@ -6612,9 +6608,9 @@ pub struct CommentInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CommentInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CommentInsertCall<'a, C, A> {} -impl<'a, C, NC, A> CommentInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CommentInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6753,7 +6749,7 @@ impl<'a, C, NC, A> CommentInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Comment) -> CommentInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Comment) -> CommentInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6763,7 +6759,7 @@ impl<'a, C, NC, A> CommentInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the activity to reply to. - pub fn activity_id(mut self, new_value: &str) -> CommentInsertCall<'a, C, NC, A> { + pub fn activity_id(mut self, new_value: &str) -> CommentInsertCall<'a, C, A> { self._activity_id = new_value.to_string(); self } @@ -6774,7 +6770,7 @@ impl<'a, C, NC, A> CommentInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6795,7 +6791,7 @@ impl<'a, C, NC, A> CommentInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CommentInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CommentInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6812,7 +6808,7 @@ impl<'a, C, NC, A> CommentInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CommentInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CommentInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6853,10 +6849,10 @@ impl<'a, C, NC, A> CommentInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct CommentListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CommentListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, _activity_id: String, _sort_order: Option, _page_token: Option, @@ -6866,9 +6862,9 @@ pub struct CommentListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CommentListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CommentListCall<'a, C, A> {} -impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CommentListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7009,7 +7005,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The ID of the activity to get comments for. - pub fn activity_id(mut self, new_value: &str) -> CommentListCall<'a, C, NC, A> { + pub fn activity_id(mut self, new_value: &str) -> CommentListCall<'a, C, A> { self._activity_id = new_value.to_string(); self } @@ -7017,7 +7013,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The order in which to sort the list of comments. - pub fn sort_order(mut self, new_value: &str) -> CommentListCall<'a, C, NC, A> { + pub fn sort_order(mut self, new_value: &str) -> CommentListCall<'a, C, A> { self._sort_order = Some(new_value.to_string()); self } @@ -7025,7 +7021,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The continuation token, which is used to page through large result sets. To get the next page of results, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> CommentListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> CommentListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -7033,7 +7029,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The maximum number of comments to include in the response, which is used for paging. For any response, the actual number returned might be less than the specified maxResults. - pub fn max_results(mut self, new_value: u32) -> CommentListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> CommentListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -7044,7 +7040,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7065,7 +7061,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CommentListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CommentListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7082,7 +7078,7 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CommentListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CommentListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7120,19 +7116,19 @@ impl<'a, C, NC, A> CommentListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct CommentGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CommentGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, _comment_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CommentGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CommentGetCall<'a, C, A> {} -impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CommentGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7264,7 +7260,7 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The ID of the comment to get. - pub fn comment_id(mut self, new_value: &str) -> CommentGetCall<'a, C, NC, A> { + pub fn comment_id(mut self, new_value: &str) -> CommentGetCall<'a, C, A> { self._comment_id = new_value.to_string(); self } @@ -7275,7 +7271,7 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CommentGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7296,7 +7292,7 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CommentGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CommentGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7313,7 +7309,7 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CommentGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CommentGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7353,10 +7349,10 @@ impl<'a, C, NC, A> CommentGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct AudienceListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AudienceListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a PlusDomains, + hub: &'a PlusDomains, _user_id: String, _page_token: Option, _max_results: Option, @@ -7365,9 +7361,9 @@ pub struct AudienceListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AudienceListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AudienceListCall<'a, C, A> {} -impl<'a, C, NC, A> AudienceListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AudienceListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7505,7 +7501,7 @@ impl<'a, C, NC, A> AudienceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of the user to get audiences for. The special value "me" can be used to indicate the authenticated user. - pub fn user_id(mut self, new_value: &str) -> AudienceListCall<'a, C, NC, A> { + pub fn user_id(mut self, new_value: &str) -> AudienceListCall<'a, C, A> { self._user_id = new_value.to_string(); self } @@ -7513,7 +7509,7 @@ impl<'a, C, NC, A> AudienceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The continuation token, which is used to page through large result sets. To get the next page of results, set this parameter to the value of "nextPageToken" from the previous response. - pub fn page_token(mut self, new_value: &str) -> AudienceListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> AudienceListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -7521,7 +7517,7 @@ impl<'a, C, NC, A> AudienceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The maximum number of circles to include in the response, which is used for paging. For any response, the actual number returned might be less than the specified maxResults. - pub fn max_results(mut self, new_value: u32) -> AudienceListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> AudienceListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -7532,7 +7528,7 @@ impl<'a, C, NC, A> AudienceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AudienceListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AudienceListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7553,7 +7549,7 @@ impl<'a, C, NC, A> AudienceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AudienceListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AudienceListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7570,7 +7566,7 @@ impl<'a, C, NC, A> AudienceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AudienceListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AudienceListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/prediction1d6/Cargo.toml b/gen/prediction1d6/Cargo.toml index 213549880e3..2bf4649272d 100644 --- a/gen/prediction1d6/Cargo.toml +++ b/gen/prediction1d6/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-prediction1d6" -version = "0.1.4+20140522" +version = "0.1.5+20140522" authors = ["Sebastian Thiel "] description = "A complete library to interact with prediction (protocol v1.6)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/prediction1d6" homepage = "https://developers.google.com/prediction/docs/developer-guide" -documentation = "http://byron.github.io/google-apis-rs/google-prediction1d6" +documentation = "http://byron.github.io/google-apis-rs/google_prediction1d6" license = "MIT" keywords = ["prediction", "google", "protocol", "web", "api"] diff --git a/gen/prediction1d6/README.md b/gen/prediction1d6/README.md index adc0f2e2ab7..90be40d16ff 100644 --- a/gen/prediction1d6/README.md +++ b/gen/prediction1d6/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-prediction1d6` library allows access to all features of the *Google prediction* service. -This documentation was generated from *prediction* crate version *0.1.4+20140522*, where *20140522* is the exact revision of the *prediction:v1.6* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *prediction* crate version *0.1.5+20140522*, where *20140522* is the exact revision of the *prediction:v1.6* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *prediction* *v1d6* API can be found at the [official documentation site](https://developers.google.com/prediction/docs/developer-guide). diff --git a/gen/prediction1d6/src/cmn.rs b/gen/prediction1d6/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/prediction1d6/src/cmn.rs +++ b/gen/prediction1d6/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/prediction1d6/src/lib.rs b/gen/prediction1d6/src/lib.rs index da71d739c4c..af49913bc8f 100644 --- a/gen/prediction1d6/src/lib.rs +++ b/gen/prediction1d6/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *prediction* crate version *0.1.4+20140522*, where *20140522* is the exact revision of the *prediction:v1.6* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *prediction* crate version *0.1.5+20140522*, where *20140522* is the exact revision of the *prediction:v1.6* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *prediction* *v1d6* API can be found at the //! [official documentation site](https://developers.google.com/prediction/docs/developer-guide). @@ -198,7 +198,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -307,37 +306,34 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Prediction { +pub struct Prediction { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Prediction {} +impl<'a, C, A> Hub for Prediction {} -impl<'a, C, NC, A> Prediction - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Prediction + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Prediction { + pub fn new(client: C, authenticator: A) -> Prediction { Prediction { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn hostedmodels(&'a self) -> HostedmodelMethods<'a, C, NC, A> { + pub fn hostedmodels(&'a self) -> HostedmodelMethods<'a, C, A> { HostedmodelMethods { hub: &self } } - pub fn trainedmodels(&'a self) -> TrainedmodelMethods<'a, C, NC, A> { + pub fn trainedmodels(&'a self) -> TrainedmodelMethods<'a, C, A> { TrainedmodelMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -849,15 +845,15 @@ impl Part for OutputOutputMulti {} /// let rb = hub.trainedmodels(); /// # } /// ``` -pub struct TrainedmodelMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TrainedmodelMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Prediction, + hub: &'a Prediction, } -impl<'a, C, NC, A> MethodsBuilder for TrainedmodelMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TrainedmodelMethods<'a, C, A> {} -impl<'a, C, NC, A> TrainedmodelMethods<'a, C, NC, A> { +impl<'a, C, A> TrainedmodelMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -867,7 +863,7 @@ impl<'a, C, NC, A> TrainedmodelMethods<'a, C, NC, A> { /// /// * `project` - The project associated with the model. /// * `id` - The unique name for the predictive model. - pub fn get(&self, project: &str, id: &str) -> TrainedmodelGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, id: &str) -> TrainedmodelGetCall<'a, C, A> { TrainedmodelGetCall { hub: self.hub, _project: project.to_string(), @@ -887,7 +883,7 @@ impl<'a, C, NC, A> TrainedmodelMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - The project associated with the model. /// * `id` - The unique name for the predictive model. - pub fn update(&self, request: &Update, project: &str, id: &str) -> TrainedmodelUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Update, project: &str, id: &str) -> TrainedmodelUpdateCall<'a, C, A> { TrainedmodelUpdateCall { hub: self.hub, _request: request.clone(), @@ -906,7 +902,7 @@ impl<'a, C, NC, A> TrainedmodelMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - The project associated with the model. - pub fn list(&self, project: &str) -> TrainedmodelListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> TrainedmodelListCall<'a, C, A> { TrainedmodelListCall { hub: self.hub, _project: project.to_string(), @@ -926,7 +922,7 @@ impl<'a, C, NC, A> TrainedmodelMethods<'a, C, NC, A> { /// /// * `project` - The project associated with the model. /// * `id` - The unique name for the predictive model. - pub fn delete(&self, project: &str, id: &str) -> TrainedmodelDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, id: &str) -> TrainedmodelDeleteCall<'a, C, A> { TrainedmodelDeleteCall { hub: self.hub, _project: project.to_string(), @@ -945,7 +941,7 @@ impl<'a, C, NC, A> TrainedmodelMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `project` - The project associated with the model. - pub fn insert(&self, request: &Insert, project: &str) -> TrainedmodelInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Insert, project: &str) -> TrainedmodelInsertCall<'a, C, A> { TrainedmodelInsertCall { hub: self.hub, _request: request.clone(), @@ -964,7 +960,7 @@ impl<'a, C, NC, A> TrainedmodelMethods<'a, C, NC, A> { /// /// * `project` - The project associated with the model. /// * `id` - The unique name for the predictive model. - pub fn analyze(&self, project: &str, id: &str) -> TrainedmodelAnalyzeCall<'a, C, NC, A> { + pub fn analyze(&self, project: &str, id: &str) -> TrainedmodelAnalyzeCall<'a, C, A> { TrainedmodelAnalyzeCall { hub: self.hub, _project: project.to_string(), @@ -984,7 +980,7 @@ impl<'a, C, NC, A> TrainedmodelMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - The project associated with the model. /// * `id` - The unique name for the predictive model. - pub fn predict(&self, request: &Input, project: &str, id: &str) -> TrainedmodelPredictCall<'a, C, NC, A> { + pub fn predict(&self, request: &Input, project: &str, id: &str) -> TrainedmodelPredictCall<'a, C, A> { TrainedmodelPredictCall { hub: self.hub, _request: request.clone(), @@ -1027,15 +1023,15 @@ impl<'a, C, NC, A> TrainedmodelMethods<'a, C, NC, A> { /// let rb = hub.hostedmodels(); /// # } /// ``` -pub struct HostedmodelMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct HostedmodelMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Prediction, + hub: &'a Prediction, } -impl<'a, C, NC, A> MethodsBuilder for HostedmodelMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for HostedmodelMethods<'a, C, A> {} -impl<'a, C, NC, A> HostedmodelMethods<'a, C, NC, A> { +impl<'a, C, A> HostedmodelMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1046,7 +1042,7 @@ impl<'a, C, NC, A> HostedmodelMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - The project associated with the model. /// * `hostedModelName` - The name of a hosted model. - pub fn predict(&self, request: &Input, project: &str, hosted_model_name: &str) -> HostedmodelPredictCall<'a, C, NC, A> { + pub fn predict(&self, request: &Input, project: &str, hosted_model_name: &str) -> HostedmodelPredictCall<'a, C, A> { HostedmodelPredictCall { hub: self.hub, _request: request.clone(), @@ -1097,10 +1093,10 @@ impl<'a, C, NC, A> HostedmodelMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct TrainedmodelGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TrainedmodelGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Prediction, + hub: &'a Prediction, _project: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -1108,9 +1104,9 @@ pub struct TrainedmodelGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TrainedmodelGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TrainedmodelGetCall<'a, C, A> {} -impl<'a, C, NC, A> TrainedmodelGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TrainedmodelGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1243,7 +1239,7 @@ impl<'a, C, NC, A> TrainedmodelGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The project associated with the model. - pub fn project(mut self, new_value: &str) -> TrainedmodelGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TrainedmodelGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1253,7 +1249,7 @@ impl<'a, C, NC, A> TrainedmodelGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The unique name for the predictive model. - pub fn id(mut self, new_value: &str) -> TrainedmodelGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> TrainedmodelGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -1264,7 +1260,7 @@ impl<'a, C, NC, A> TrainedmodelGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TrainedmodelGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TrainedmodelGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1285,7 +1281,7 @@ impl<'a, C, NC, A> TrainedmodelGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TrainedmodelGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TrainedmodelGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1302,7 +1298,7 @@ impl<'a, C, NC, A> TrainedmodelGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TrainedmodelGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TrainedmodelGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1346,10 +1342,10 @@ impl<'a, C, NC, A> TrainedmodelGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct TrainedmodelUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TrainedmodelUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Prediction, + hub: &'a Prediction, _request: Update, _project: String, _id: String, @@ -1358,9 +1354,9 @@ pub struct TrainedmodelUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TrainedmodelUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TrainedmodelUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> TrainedmodelUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TrainedmodelUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1500,7 +1496,7 @@ impl<'a, C, NC, A> TrainedmodelUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Update) -> TrainedmodelUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Update) -> TrainedmodelUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1510,7 +1506,7 @@ impl<'a, C, NC, A> TrainedmodelUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The project associated with the model. - pub fn project(mut self, new_value: &str) -> TrainedmodelUpdateCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TrainedmodelUpdateCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1520,7 +1516,7 @@ impl<'a, C, NC, A> TrainedmodelUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The unique name for the predictive model. - pub fn id(mut self, new_value: &str) -> TrainedmodelUpdateCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> TrainedmodelUpdateCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -1531,7 +1527,7 @@ impl<'a, C, NC, A> TrainedmodelUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TrainedmodelUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TrainedmodelUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1552,7 +1548,7 @@ impl<'a, C, NC, A> TrainedmodelUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TrainedmodelUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TrainedmodelUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1569,7 +1565,7 @@ impl<'a, C, NC, A> TrainedmodelUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TrainedmodelUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TrainedmodelUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1609,10 +1605,10 @@ impl<'a, C, NC, A> TrainedmodelUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct TrainedmodelListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TrainedmodelListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Prediction, + hub: &'a Prediction, _project: String, _page_token: Option, _max_results: Option, @@ -1621,9 +1617,9 @@ pub struct TrainedmodelListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TrainedmodelListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TrainedmodelListCall<'a, C, A> {} -impl<'a, C, NC, A> TrainedmodelListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TrainedmodelListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1761,7 +1757,7 @@ impl<'a, C, NC, A> TrainedmodelListCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The project associated with the model. - pub fn project(mut self, new_value: &str) -> TrainedmodelListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TrainedmodelListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1769,7 +1765,7 @@ impl<'a, C, NC, A> TrainedmodelListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Pagination token. - pub fn page_token(mut self, new_value: &str) -> TrainedmodelListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TrainedmodelListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -1777,7 +1773,7 @@ impl<'a, C, NC, A> TrainedmodelListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Maximum number of results to return. - pub fn max_results(mut self, new_value: u32) -> TrainedmodelListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> TrainedmodelListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -1788,7 +1784,7 @@ impl<'a, C, NC, A> TrainedmodelListCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TrainedmodelListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TrainedmodelListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1809,7 +1805,7 @@ impl<'a, C, NC, A> TrainedmodelListCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TrainedmodelListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TrainedmodelListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1826,7 +1822,7 @@ impl<'a, C, NC, A> TrainedmodelListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TrainedmodelListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TrainedmodelListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1864,10 +1860,10 @@ impl<'a, C, NC, A> TrainedmodelListCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct TrainedmodelDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TrainedmodelDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Prediction, + hub: &'a Prediction, _project: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -1875,9 +1871,9 @@ pub struct TrainedmodelDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TrainedmodelDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TrainedmodelDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> TrainedmodelDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TrainedmodelDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1999,7 +1995,7 @@ impl<'a, C, NC, A> TrainedmodelDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The project associated with the model. - pub fn project(mut self, new_value: &str) -> TrainedmodelDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TrainedmodelDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2009,7 +2005,7 @@ impl<'a, C, NC, A> TrainedmodelDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The unique name for the predictive model. - pub fn id(mut self, new_value: &str) -> TrainedmodelDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> TrainedmodelDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -2020,7 +2016,7 @@ impl<'a, C, NC, A> TrainedmodelDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TrainedmodelDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TrainedmodelDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2041,7 +2037,7 @@ impl<'a, C, NC, A> TrainedmodelDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TrainedmodelDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TrainedmodelDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2058,7 +2054,7 @@ impl<'a, C, NC, A> TrainedmodelDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TrainedmodelDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TrainedmodelDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2102,10 +2098,10 @@ impl<'a, C, NC, A> TrainedmodelDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct TrainedmodelInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TrainedmodelInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Prediction, + hub: &'a Prediction, _request: Insert, _project: String, _delegate: Option<&'a mut Delegate>, @@ -2113,9 +2109,9 @@ pub struct TrainedmodelInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TrainedmodelInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TrainedmodelInsertCall<'a, C, A> {} -impl<'a, C, NC, A> TrainedmodelInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TrainedmodelInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2254,7 +2250,7 @@ impl<'a, C, NC, A> TrainedmodelInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Insert) -> TrainedmodelInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Insert) -> TrainedmodelInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2264,7 +2260,7 @@ impl<'a, C, NC, A> TrainedmodelInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The project associated with the model. - pub fn project(mut self, new_value: &str) -> TrainedmodelInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TrainedmodelInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2275,7 +2271,7 @@ impl<'a, C, NC, A> TrainedmodelInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TrainedmodelInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TrainedmodelInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2296,7 +2292,7 @@ impl<'a, C, NC, A> TrainedmodelInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TrainedmodelInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TrainedmodelInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2313,7 +2309,7 @@ impl<'a, C, NC, A> TrainedmodelInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TrainedmodelInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TrainedmodelInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2351,10 +2347,10 @@ impl<'a, C, NC, A> TrainedmodelInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct TrainedmodelAnalyzeCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TrainedmodelAnalyzeCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Prediction, + hub: &'a Prediction, _project: String, _id: String, _delegate: Option<&'a mut Delegate>, @@ -2362,9 +2358,9 @@ pub struct TrainedmodelAnalyzeCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TrainedmodelAnalyzeCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TrainedmodelAnalyzeCall<'a, C, A> {} -impl<'a, C, NC, A> TrainedmodelAnalyzeCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TrainedmodelAnalyzeCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2497,7 +2493,7 @@ impl<'a, C, NC, A> TrainedmodelAnalyzeCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The project associated with the model. - pub fn project(mut self, new_value: &str) -> TrainedmodelAnalyzeCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TrainedmodelAnalyzeCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2507,7 +2503,7 @@ impl<'a, C, NC, A> TrainedmodelAnalyzeCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The unique name for the predictive model. - pub fn id(mut self, new_value: &str) -> TrainedmodelAnalyzeCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> TrainedmodelAnalyzeCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -2518,7 +2514,7 @@ impl<'a, C, NC, A> TrainedmodelAnalyzeCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TrainedmodelAnalyzeCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TrainedmodelAnalyzeCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2539,7 +2535,7 @@ impl<'a, C, NC, A> TrainedmodelAnalyzeCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TrainedmodelAnalyzeCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TrainedmodelAnalyzeCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2556,7 +2552,7 @@ impl<'a, C, NC, A> TrainedmodelAnalyzeCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TrainedmodelAnalyzeCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TrainedmodelAnalyzeCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2600,10 +2596,10 @@ impl<'a, C, NC, A> TrainedmodelAnalyzeCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct TrainedmodelPredictCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TrainedmodelPredictCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Prediction, + hub: &'a Prediction, _request: Input, _project: String, _id: String, @@ -2612,9 +2608,9 @@ pub struct TrainedmodelPredictCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TrainedmodelPredictCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TrainedmodelPredictCall<'a, C, A> {} -impl<'a, C, NC, A> TrainedmodelPredictCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TrainedmodelPredictCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2754,7 +2750,7 @@ impl<'a, C, NC, A> TrainedmodelPredictCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Input) -> TrainedmodelPredictCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Input) -> TrainedmodelPredictCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2764,7 +2760,7 @@ impl<'a, C, NC, A> TrainedmodelPredictCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The project associated with the model. - pub fn project(mut self, new_value: &str) -> TrainedmodelPredictCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TrainedmodelPredictCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2774,7 +2770,7 @@ impl<'a, C, NC, A> TrainedmodelPredictCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The unique name for the predictive model. - pub fn id(mut self, new_value: &str) -> TrainedmodelPredictCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> TrainedmodelPredictCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -2785,7 +2781,7 @@ impl<'a, C, NC, A> TrainedmodelPredictCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TrainedmodelPredictCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TrainedmodelPredictCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2806,7 +2802,7 @@ impl<'a, C, NC, A> TrainedmodelPredictCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TrainedmodelPredictCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TrainedmodelPredictCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2823,7 +2819,7 @@ impl<'a, C, NC, A> TrainedmodelPredictCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TrainedmodelPredictCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TrainedmodelPredictCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2867,10 +2863,10 @@ impl<'a, C, NC, A> TrainedmodelPredictCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct HostedmodelPredictCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct HostedmodelPredictCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Prediction, + hub: &'a Prediction, _request: Input, _project: String, _hosted_model_name: String, @@ -2879,9 +2875,9 @@ pub struct HostedmodelPredictCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for HostedmodelPredictCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for HostedmodelPredictCall<'a, C, A> {} -impl<'a, C, NC, A> HostedmodelPredictCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> HostedmodelPredictCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3021,7 +3017,7 @@ impl<'a, C, NC, A> HostedmodelPredictCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Input) -> HostedmodelPredictCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Input) -> HostedmodelPredictCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3031,7 +3027,7 @@ impl<'a, C, NC, A> HostedmodelPredictCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The project associated with the model. - pub fn project(mut self, new_value: &str) -> HostedmodelPredictCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> HostedmodelPredictCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -3041,7 +3037,7 @@ impl<'a, C, NC, A> HostedmodelPredictCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The name of a hosted model. - pub fn hosted_model_name(mut self, new_value: &str) -> HostedmodelPredictCall<'a, C, NC, A> { + pub fn hosted_model_name(mut self, new_value: &str) -> HostedmodelPredictCall<'a, C, A> { self._hosted_model_name = new_value.to_string(); self } @@ -3052,7 +3048,7 @@ impl<'a, C, NC, A> HostedmodelPredictCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> HostedmodelPredictCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> HostedmodelPredictCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3073,7 +3069,7 @@ impl<'a, C, NC, A> HostedmodelPredictCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> HostedmodelPredictCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> HostedmodelPredictCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3090,7 +3086,7 @@ impl<'a, C, NC, A> HostedmodelPredictCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> HostedmodelPredictCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> HostedmodelPredictCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/pubsub1_beta2/Cargo.toml b/gen/pubsub1_beta2/Cargo.toml index b10f5c9ea10..ea9e14d1047 100644 --- a/gen/pubsub1_beta2/Cargo.toml +++ b/gen/pubsub1_beta2/Cargo.toml @@ -4,11 +4,11 @@ [package] name = "google-pubsub1_beta2" -version = "0.1.4+20150326" +version = "0.1.5+20150326" authors = ["Sebastian Thiel "] description = "A complete library to interact with pubsub (protocol v1beta2)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/pubsub1_beta2" -documentation = "http://byron.github.io/google-apis-rs/google-pubsub1_beta2" +documentation = "http://byron.github.io/google-apis-rs/google_pubsub1_beta2" license = "MIT" keywords = ["pubsub", "google", "protocol", "web", "api"] diff --git a/gen/pubsub1_beta2/README.md b/gen/pubsub1_beta2/README.md index 8e1e181e0cd..e306fc8175e 100644 --- a/gen/pubsub1_beta2/README.md +++ b/gen/pubsub1_beta2/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-pubsub1_beta2` library allows access to all features of the *Google pubsub* service. -This documentation was generated from *pubsub* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *pubsub:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *pubsub* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *pubsub:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. # Features Handle the following *Resources* with ease from the central [hub](http://byron.github.io/google-apis-rs/google-pubsub1_beta2/struct.Pubsub.html) ... diff --git a/gen/pubsub1_beta2/src/cmn.rs b/gen/pubsub1_beta2/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/pubsub1_beta2/src/cmn.rs +++ b/gen/pubsub1_beta2/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/pubsub1_beta2/src/lib.rs b/gen/pubsub1_beta2/src/lib.rs index 712986a7eeb..7ad5cc4677d 100644 --- a/gen/pubsub1_beta2/src/lib.rs +++ b/gen/pubsub1_beta2/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *pubsub* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *pubsub:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *pubsub* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *pubsub:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/master/gen/pubsub1_beta2). //! # Features //! @@ -195,7 +195,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -296,34 +295,31 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Pubsub { +pub struct Pubsub { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Pubsub {} +impl<'a, C, A> Hub for Pubsub {} -impl<'a, C, NC, A> Pubsub - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Pubsub + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Pubsub { + pub fn new(client: C, authenticator: A) -> Pubsub { Pubsub { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn projects(&'a self) -> ProjectMethods<'a, C, NC, A> { + pub fn projects(&'a self) -> ProjectMethods<'a, C, A> { ProjectMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -688,15 +684,15 @@ impl ResponseResult for Subscription {} /// let rb = hub.projects(); /// # } /// ``` -pub struct ProjectMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Pubsub, + hub: &'a Pubsub, } -impl<'a, C, NC, A> MethodsBuilder for ProjectMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ProjectMethods<'a, C, A> {} -impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { +impl<'a, C, A> ProjectMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -705,7 +701,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - No description provided. - pub fn topics_list(&self, project: &str) -> ProjectTopicListCall<'a, C, NC, A> { + pub fn topics_list(&self, project: &str) -> ProjectTopicListCall<'a, C, A> { ProjectTopicListCall { hub: self.hub, _project: project.to_string(), @@ -725,7 +721,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `subscription` - No description provided. - pub fn subscriptions_pull(&self, request: &PullRequest, subscription: &str) -> ProjectSubscriptionPullCall<'a, C, NC, A> { + pub fn subscriptions_pull(&self, request: &PullRequest, subscription: &str) -> ProjectSubscriptionPullCall<'a, C, A> { ProjectSubscriptionPullCall { hub: self.hub, _request: request.clone(), @@ -744,7 +740,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `name` - No description provided. - pub fn topics_create(&self, request: &Topic, name: &str) -> ProjectTopicCreateCall<'a, C, NC, A> { + pub fn topics_create(&self, request: &Topic, name: &str) -> ProjectTopicCreateCall<'a, C, A> { ProjectTopicCreateCall { hub: self.hub, _request: request.clone(), @@ -762,7 +758,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// # Arguments /// /// * `topic` - No description provided. - pub fn topics_delete(&self, topic: &str) -> ProjectTopicDeleteCall<'a, C, NC, A> { + pub fn topics_delete(&self, topic: &str) -> ProjectTopicDeleteCall<'a, C, A> { ProjectTopicDeleteCall { hub: self.hub, _topic: topic.to_string(), @@ -780,7 +776,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `subscription` - No description provided. - pub fn subscriptions_modify_push_config(&self, request: &ModifyPushConfigRequest, subscription: &str) -> ProjectSubscriptionModifyPushConfigCall<'a, C, NC, A> { + pub fn subscriptions_modify_push_config(&self, request: &ModifyPushConfigRequest, subscription: &str) -> ProjectSubscriptionModifyPushConfigCall<'a, C, A> { ProjectSubscriptionModifyPushConfigCall { hub: self.hub, _request: request.clone(), @@ -799,7 +795,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `topic` - No description provided. - pub fn topics_publish(&self, request: &PublishRequest, topic: &str) -> ProjectTopicPublishCall<'a, C, NC, A> { + pub fn topics_publish(&self, request: &PublishRequest, topic: &str) -> ProjectTopicPublishCall<'a, C, A> { ProjectTopicPublishCall { hub: self.hub, _request: request.clone(), @@ -817,7 +813,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// # Arguments /// /// * `topic` - No description provided. - pub fn topics_get(&self, topic: &str) -> ProjectTopicGetCall<'a, C, NC, A> { + pub fn topics_get(&self, topic: &str) -> ProjectTopicGetCall<'a, C, A> { ProjectTopicGetCall { hub: self.hub, _topic: topic.to_string(), @@ -835,7 +831,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `subscription` - No description provided. - pub fn subscriptions_modify_ack_deadline(&self, request: &ModifyAckDeadlineRequest, subscription: &str) -> ProjectSubscriptionModifyAckDeadlineCall<'a, C, NC, A> { + pub fn subscriptions_modify_ack_deadline(&self, request: &ModifyAckDeadlineRequest, subscription: &str) -> ProjectSubscriptionModifyAckDeadlineCall<'a, C, A> { ProjectSubscriptionModifyAckDeadlineCall { hub: self.hub, _request: request.clone(), @@ -854,7 +850,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `subscription` - No description provided. - pub fn subscriptions_acknowledge(&self, request: &AcknowledgeRequest, subscription: &str) -> ProjectSubscriptionAcknowledgeCall<'a, C, NC, A> { + pub fn subscriptions_acknowledge(&self, request: &AcknowledgeRequest, subscription: &str) -> ProjectSubscriptionAcknowledgeCall<'a, C, A> { ProjectSubscriptionAcknowledgeCall { hub: self.hub, _request: request.clone(), @@ -872,7 +868,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// # Arguments /// /// * `subscription` - No description provided. - pub fn subscriptions_delete(&self, subscription: &str) -> ProjectSubscriptionDeleteCall<'a, C, NC, A> { + pub fn subscriptions_delete(&self, subscription: &str) -> ProjectSubscriptionDeleteCall<'a, C, A> { ProjectSubscriptionDeleteCall { hub: self.hub, _subscription: subscription.to_string(), @@ -890,7 +886,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `name` - No description provided. - pub fn subscriptions_create(&self, request: &Subscription, name: &str) -> ProjectSubscriptionCreateCall<'a, C, NC, A> { + pub fn subscriptions_create(&self, request: &Subscription, name: &str) -> ProjectSubscriptionCreateCall<'a, C, A> { ProjectSubscriptionCreateCall { hub: self.hub, _request: request.clone(), @@ -908,7 +904,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// # Arguments /// /// * `subscription` - No description provided. - pub fn subscriptions_get(&self, subscription: &str) -> ProjectSubscriptionGetCall<'a, C, NC, A> { + pub fn subscriptions_get(&self, subscription: &str) -> ProjectSubscriptionGetCall<'a, C, A> { ProjectSubscriptionGetCall { hub: self.hub, _subscription: subscription.to_string(), @@ -925,7 +921,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// # Arguments /// /// * `topic` - No description provided. - pub fn topics_subscriptions_list(&self, topic: &str) -> ProjectTopicSubscriptionListCall<'a, C, NC, A> { + pub fn topics_subscriptions_list(&self, topic: &str) -> ProjectTopicSubscriptionListCall<'a, C, A> { ProjectTopicSubscriptionListCall { hub: self.hub, _topic: topic.to_string(), @@ -944,7 +940,7 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - No description provided. - pub fn subscriptions_list(&self, project: &str) -> ProjectSubscriptionListCall<'a, C, NC, A> { + pub fn subscriptions_list(&self, project: &str) -> ProjectSubscriptionListCall<'a, C, A> { ProjectSubscriptionListCall { hub: self.hub, _project: project.to_string(), @@ -997,10 +993,10 @@ impl<'a, C, NC, A> ProjectMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct ProjectTopicListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectTopicListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Pubsub, + hub: &'a Pubsub, _project: String, _page_token: Option, _page_size: Option, @@ -1009,9 +1005,9 @@ pub struct ProjectTopicListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectTopicListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectTopicListCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectTopicListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectTopicListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1152,21 +1148,21 @@ impl<'a, C, NC, A> ProjectTopicListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn project(mut self, new_value: &str) -> ProjectTopicListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ProjectTopicListCall<'a, C, A> { self._project = new_value.to_string(); self } /// Sets the *page token* query property to the given value. /// /// - pub fn page_token(mut self, new_value: &str) -> ProjectTopicListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ProjectTopicListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } /// Sets the *page size* query property to the given value. /// /// - pub fn page_size(mut self, new_value: i32) -> ProjectTopicListCall<'a, C, NC, A> { + pub fn page_size(mut self, new_value: i32) -> ProjectTopicListCall<'a, C, A> { self._page_size = Some(new_value); self } @@ -1177,7 +1173,7 @@ impl<'a, C, NC, A> ProjectTopicListCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectTopicListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectTopicListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1198,7 +1194,7 @@ impl<'a, C, NC, A> ProjectTopicListCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectTopicListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectTopicListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1215,7 +1211,7 @@ impl<'a, C, NC, A> ProjectTopicListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectTopicListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectTopicListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1259,10 +1255,10 @@ impl<'a, C, NC, A> ProjectTopicListCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct ProjectSubscriptionPullCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectSubscriptionPullCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Pubsub, + hub: &'a Pubsub, _request: PullRequest, _subscription: String, _delegate: Option<&'a mut Delegate>, @@ -1270,9 +1266,9 @@ pub struct ProjectSubscriptionPullCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectSubscriptionPullCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectSubscriptionPullCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectSubscriptionPullCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectSubscriptionPullCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1415,7 +1411,7 @@ impl<'a, C, NC, A> ProjectSubscriptionPullCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PullRequest) -> ProjectSubscriptionPullCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PullRequest) -> ProjectSubscriptionPullCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1424,7 +1420,7 @@ impl<'a, C, NC, A> ProjectSubscriptionPullCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn subscription(mut self, new_value: &str) -> ProjectSubscriptionPullCall<'a, C, NC, A> { + pub fn subscription(mut self, new_value: &str) -> ProjectSubscriptionPullCall<'a, C, A> { self._subscription = new_value.to_string(); self } @@ -1435,7 +1431,7 @@ impl<'a, C, NC, A> ProjectSubscriptionPullCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectSubscriptionPullCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectSubscriptionPullCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1456,7 +1452,7 @@ impl<'a, C, NC, A> ProjectSubscriptionPullCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectSubscriptionPullCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectSubscriptionPullCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1473,7 +1469,7 @@ impl<'a, C, NC, A> ProjectSubscriptionPullCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectSubscriptionPullCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectSubscriptionPullCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1517,10 +1513,10 @@ impl<'a, C, NC, A> ProjectSubscriptionPullCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct ProjectTopicCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectTopicCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Pubsub, + hub: &'a Pubsub, _request: Topic, _name: String, _delegate: Option<&'a mut Delegate>, @@ -1528,9 +1524,9 @@ pub struct ProjectTopicCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectTopicCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectTopicCreateCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectTopicCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectTopicCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1673,7 +1669,7 @@ impl<'a, C, NC, A> ProjectTopicCreateCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Topic) -> ProjectTopicCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Topic) -> ProjectTopicCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1682,7 +1678,7 @@ impl<'a, C, NC, A> ProjectTopicCreateCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn name(mut self, new_value: &str) -> ProjectTopicCreateCall<'a, C, NC, A> { + pub fn name(mut self, new_value: &str) -> ProjectTopicCreateCall<'a, C, A> { self._name = new_value.to_string(); self } @@ -1693,7 +1689,7 @@ impl<'a, C, NC, A> ProjectTopicCreateCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectTopicCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectTopicCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1714,7 +1710,7 @@ impl<'a, C, NC, A> ProjectTopicCreateCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectTopicCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectTopicCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1731,7 +1727,7 @@ impl<'a, C, NC, A> ProjectTopicCreateCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectTopicCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectTopicCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1769,19 +1765,19 @@ impl<'a, C, NC, A> ProjectTopicCreateCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct ProjectTopicDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectTopicDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Pubsub, + hub: &'a Pubsub, _topic: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectTopicDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectTopicDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectTopicDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectTopicDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1916,7 +1912,7 @@ impl<'a, C, NC, A> ProjectTopicDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn topic(mut self, new_value: &str) -> ProjectTopicDeleteCall<'a, C, NC, A> { + pub fn topic(mut self, new_value: &str) -> ProjectTopicDeleteCall<'a, C, A> { self._topic = new_value.to_string(); self } @@ -1927,7 +1923,7 @@ impl<'a, C, NC, A> ProjectTopicDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectTopicDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectTopicDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1948,7 +1944,7 @@ impl<'a, C, NC, A> ProjectTopicDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectTopicDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectTopicDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1965,7 +1961,7 @@ impl<'a, C, NC, A> ProjectTopicDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectTopicDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectTopicDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2009,10 +2005,10 @@ impl<'a, C, NC, A> ProjectTopicDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct ProjectSubscriptionModifyPushConfigCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectSubscriptionModifyPushConfigCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Pubsub, + hub: &'a Pubsub, _request: ModifyPushConfigRequest, _subscription: String, _delegate: Option<&'a mut Delegate>, @@ -2020,9 +2016,9 @@ pub struct ProjectSubscriptionModifyPushConfigCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectSubscriptionModifyPushConfigCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectSubscriptionModifyPushConfigCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectSubscriptionModifyPushConfigCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectSubscriptionModifyPushConfigCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2165,7 +2161,7 @@ impl<'a, C, NC, A> ProjectSubscriptionModifyPushConfigCall<'a, C, NC, A> where N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ModifyPushConfigRequest) -> ProjectSubscriptionModifyPushConfigCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ModifyPushConfigRequest) -> ProjectSubscriptionModifyPushConfigCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2174,7 +2170,7 @@ impl<'a, C, NC, A> ProjectSubscriptionModifyPushConfigCall<'a, C, NC, A> where N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn subscription(mut self, new_value: &str) -> ProjectSubscriptionModifyPushConfigCall<'a, C, NC, A> { + pub fn subscription(mut self, new_value: &str) -> ProjectSubscriptionModifyPushConfigCall<'a, C, A> { self._subscription = new_value.to_string(); self } @@ -2185,7 +2181,7 @@ impl<'a, C, NC, A> ProjectSubscriptionModifyPushConfigCall<'a, C, NC, A> where N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectSubscriptionModifyPushConfigCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectSubscriptionModifyPushConfigCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2206,7 +2202,7 @@ impl<'a, C, NC, A> ProjectSubscriptionModifyPushConfigCall<'a, C, NC, A> where N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectSubscriptionModifyPushConfigCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectSubscriptionModifyPushConfigCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2223,7 +2219,7 @@ impl<'a, C, NC, A> ProjectSubscriptionModifyPushConfigCall<'a, C, NC, A> where N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectSubscriptionModifyPushConfigCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectSubscriptionModifyPushConfigCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2267,10 +2263,10 @@ impl<'a, C, NC, A> ProjectSubscriptionModifyPushConfigCall<'a, C, NC, A> where N /// .doit(); /// # } /// ``` -pub struct ProjectTopicPublishCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectTopicPublishCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Pubsub, + hub: &'a Pubsub, _request: PublishRequest, _topic: String, _delegate: Option<&'a mut Delegate>, @@ -2278,9 +2274,9 @@ pub struct ProjectTopicPublishCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectTopicPublishCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectTopicPublishCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectTopicPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectTopicPublishCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2423,7 +2419,7 @@ impl<'a, C, NC, A> ProjectTopicPublishCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PublishRequest) -> ProjectTopicPublishCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PublishRequest) -> ProjectTopicPublishCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2432,7 +2428,7 @@ impl<'a, C, NC, A> ProjectTopicPublishCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn topic(mut self, new_value: &str) -> ProjectTopicPublishCall<'a, C, NC, A> { + pub fn topic(mut self, new_value: &str) -> ProjectTopicPublishCall<'a, C, A> { self._topic = new_value.to_string(); self } @@ -2443,7 +2439,7 @@ impl<'a, C, NC, A> ProjectTopicPublishCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectTopicPublishCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectTopicPublishCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2464,7 +2460,7 @@ impl<'a, C, NC, A> ProjectTopicPublishCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectTopicPublishCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectTopicPublishCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2481,7 +2477,7 @@ impl<'a, C, NC, A> ProjectTopicPublishCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectTopicPublishCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectTopicPublishCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2519,19 +2515,19 @@ impl<'a, C, NC, A> ProjectTopicPublishCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct ProjectTopicGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectTopicGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Pubsub, + hub: &'a Pubsub, _topic: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectTopicGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectTopicGetCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectTopicGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectTopicGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2666,7 +2662,7 @@ impl<'a, C, NC, A> ProjectTopicGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn topic(mut self, new_value: &str) -> ProjectTopicGetCall<'a, C, NC, A> { + pub fn topic(mut self, new_value: &str) -> ProjectTopicGetCall<'a, C, A> { self._topic = new_value.to_string(); self } @@ -2677,7 +2673,7 @@ impl<'a, C, NC, A> ProjectTopicGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectTopicGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectTopicGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2698,7 +2694,7 @@ impl<'a, C, NC, A> ProjectTopicGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectTopicGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectTopicGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2715,7 +2711,7 @@ impl<'a, C, NC, A> ProjectTopicGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectTopicGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectTopicGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2759,10 +2755,10 @@ impl<'a, C, NC, A> ProjectTopicGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct ProjectSubscriptionModifyAckDeadlineCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectSubscriptionModifyAckDeadlineCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Pubsub, + hub: &'a Pubsub, _request: ModifyAckDeadlineRequest, _subscription: String, _delegate: Option<&'a mut Delegate>, @@ -2770,9 +2766,9 @@ pub struct ProjectSubscriptionModifyAckDeadlineCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectSubscriptionModifyAckDeadlineCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectSubscriptionModifyAckDeadlineCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectSubscriptionModifyAckDeadlineCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectSubscriptionModifyAckDeadlineCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2915,7 +2911,7 @@ impl<'a, C, NC, A> ProjectSubscriptionModifyAckDeadlineCall<'a, C, NC, A> where /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ModifyAckDeadlineRequest) -> ProjectSubscriptionModifyAckDeadlineCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ModifyAckDeadlineRequest) -> ProjectSubscriptionModifyAckDeadlineCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2924,7 +2920,7 @@ impl<'a, C, NC, A> ProjectSubscriptionModifyAckDeadlineCall<'a, C, NC, A> where /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn subscription(mut self, new_value: &str) -> ProjectSubscriptionModifyAckDeadlineCall<'a, C, NC, A> { + pub fn subscription(mut self, new_value: &str) -> ProjectSubscriptionModifyAckDeadlineCall<'a, C, A> { self._subscription = new_value.to_string(); self } @@ -2935,7 +2931,7 @@ impl<'a, C, NC, A> ProjectSubscriptionModifyAckDeadlineCall<'a, C, NC, A> where /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectSubscriptionModifyAckDeadlineCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectSubscriptionModifyAckDeadlineCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2956,7 +2952,7 @@ impl<'a, C, NC, A> ProjectSubscriptionModifyAckDeadlineCall<'a, C, NC, A> where /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectSubscriptionModifyAckDeadlineCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectSubscriptionModifyAckDeadlineCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2973,7 +2969,7 @@ impl<'a, C, NC, A> ProjectSubscriptionModifyAckDeadlineCall<'a, C, NC, A> where /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectSubscriptionModifyAckDeadlineCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectSubscriptionModifyAckDeadlineCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3017,10 +3013,10 @@ impl<'a, C, NC, A> ProjectSubscriptionModifyAckDeadlineCall<'a, C, NC, A> where /// .doit(); /// # } /// ``` -pub struct ProjectSubscriptionAcknowledgeCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectSubscriptionAcknowledgeCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Pubsub, + hub: &'a Pubsub, _request: AcknowledgeRequest, _subscription: String, _delegate: Option<&'a mut Delegate>, @@ -3028,9 +3024,9 @@ pub struct ProjectSubscriptionAcknowledgeCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectSubscriptionAcknowledgeCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectSubscriptionAcknowledgeCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectSubscriptionAcknowledgeCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectSubscriptionAcknowledgeCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3173,7 +3169,7 @@ impl<'a, C, NC, A> ProjectSubscriptionAcknowledgeCall<'a, C, NC, A> where NC: hy /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &AcknowledgeRequest) -> ProjectSubscriptionAcknowledgeCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &AcknowledgeRequest) -> ProjectSubscriptionAcknowledgeCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3182,7 +3178,7 @@ impl<'a, C, NC, A> ProjectSubscriptionAcknowledgeCall<'a, C, NC, A> where NC: hy /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn subscription(mut self, new_value: &str) -> ProjectSubscriptionAcknowledgeCall<'a, C, NC, A> { + pub fn subscription(mut self, new_value: &str) -> ProjectSubscriptionAcknowledgeCall<'a, C, A> { self._subscription = new_value.to_string(); self } @@ -3193,7 +3189,7 @@ impl<'a, C, NC, A> ProjectSubscriptionAcknowledgeCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectSubscriptionAcknowledgeCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectSubscriptionAcknowledgeCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3214,7 +3210,7 @@ impl<'a, C, NC, A> ProjectSubscriptionAcknowledgeCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectSubscriptionAcknowledgeCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectSubscriptionAcknowledgeCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3231,7 +3227,7 @@ impl<'a, C, NC, A> ProjectSubscriptionAcknowledgeCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectSubscriptionAcknowledgeCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectSubscriptionAcknowledgeCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3269,19 +3265,19 @@ impl<'a, C, NC, A> ProjectSubscriptionAcknowledgeCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct ProjectSubscriptionDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectSubscriptionDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Pubsub, + hub: &'a Pubsub, _subscription: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectSubscriptionDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectSubscriptionDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectSubscriptionDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectSubscriptionDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3416,7 +3412,7 @@ impl<'a, C, NC, A> ProjectSubscriptionDeleteCall<'a, C, NC, A> where NC: hyper:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn subscription(mut self, new_value: &str) -> ProjectSubscriptionDeleteCall<'a, C, NC, A> { + pub fn subscription(mut self, new_value: &str) -> ProjectSubscriptionDeleteCall<'a, C, A> { self._subscription = new_value.to_string(); self } @@ -3427,7 +3423,7 @@ impl<'a, C, NC, A> ProjectSubscriptionDeleteCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectSubscriptionDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectSubscriptionDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3448,7 +3444,7 @@ impl<'a, C, NC, A> ProjectSubscriptionDeleteCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectSubscriptionDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectSubscriptionDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3465,7 +3461,7 @@ impl<'a, C, NC, A> ProjectSubscriptionDeleteCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectSubscriptionDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectSubscriptionDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3509,10 +3505,10 @@ impl<'a, C, NC, A> ProjectSubscriptionDeleteCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct ProjectSubscriptionCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectSubscriptionCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Pubsub, + hub: &'a Pubsub, _request: Subscription, _name: String, _delegate: Option<&'a mut Delegate>, @@ -3520,9 +3516,9 @@ pub struct ProjectSubscriptionCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectSubscriptionCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectSubscriptionCreateCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectSubscriptionCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectSubscriptionCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3665,7 +3661,7 @@ impl<'a, C, NC, A> ProjectSubscriptionCreateCall<'a, C, NC, A> where NC: hyper:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Subscription) -> ProjectSubscriptionCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Subscription) -> ProjectSubscriptionCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3674,7 +3670,7 @@ impl<'a, C, NC, A> ProjectSubscriptionCreateCall<'a, C, NC, A> where NC: hyper:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn name(mut self, new_value: &str) -> ProjectSubscriptionCreateCall<'a, C, NC, A> { + pub fn name(mut self, new_value: &str) -> ProjectSubscriptionCreateCall<'a, C, A> { self._name = new_value.to_string(); self } @@ -3685,7 +3681,7 @@ impl<'a, C, NC, A> ProjectSubscriptionCreateCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectSubscriptionCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectSubscriptionCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3706,7 +3702,7 @@ impl<'a, C, NC, A> ProjectSubscriptionCreateCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectSubscriptionCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectSubscriptionCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3723,7 +3719,7 @@ impl<'a, C, NC, A> ProjectSubscriptionCreateCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectSubscriptionCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectSubscriptionCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3761,19 +3757,19 @@ impl<'a, C, NC, A> ProjectSubscriptionCreateCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct ProjectSubscriptionGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectSubscriptionGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Pubsub, + hub: &'a Pubsub, _subscription: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectSubscriptionGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectSubscriptionGetCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectSubscriptionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectSubscriptionGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3908,7 +3904,7 @@ impl<'a, C, NC, A> ProjectSubscriptionGetCall<'a, C, NC, A> where NC: hyper::net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn subscription(mut self, new_value: &str) -> ProjectSubscriptionGetCall<'a, C, NC, A> { + pub fn subscription(mut self, new_value: &str) -> ProjectSubscriptionGetCall<'a, C, A> { self._subscription = new_value.to_string(); self } @@ -3919,7 +3915,7 @@ impl<'a, C, NC, A> ProjectSubscriptionGetCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectSubscriptionGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectSubscriptionGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3940,7 +3936,7 @@ impl<'a, C, NC, A> ProjectSubscriptionGetCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectSubscriptionGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectSubscriptionGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3957,7 +3953,7 @@ impl<'a, C, NC, A> ProjectSubscriptionGetCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectSubscriptionGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectSubscriptionGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3997,10 +3993,10 @@ impl<'a, C, NC, A> ProjectSubscriptionGetCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct ProjectTopicSubscriptionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectTopicSubscriptionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Pubsub, + hub: &'a Pubsub, _topic: String, _page_token: Option, _page_size: Option, @@ -4009,9 +4005,9 @@ pub struct ProjectTopicSubscriptionListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectTopicSubscriptionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectTopicSubscriptionListCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectTopicSubscriptionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectTopicSubscriptionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4152,21 +4148,21 @@ impl<'a, C, NC, A> ProjectTopicSubscriptionListCall<'a, C, NC, A> where NC: hype /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn topic(mut self, new_value: &str) -> ProjectTopicSubscriptionListCall<'a, C, NC, A> { + pub fn topic(mut self, new_value: &str) -> ProjectTopicSubscriptionListCall<'a, C, A> { self._topic = new_value.to_string(); self } /// Sets the *page token* query property to the given value. /// /// - pub fn page_token(mut self, new_value: &str) -> ProjectTopicSubscriptionListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ProjectTopicSubscriptionListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } /// Sets the *page size* query property to the given value. /// /// - pub fn page_size(mut self, new_value: i32) -> ProjectTopicSubscriptionListCall<'a, C, NC, A> { + pub fn page_size(mut self, new_value: i32) -> ProjectTopicSubscriptionListCall<'a, C, A> { self._page_size = Some(new_value); self } @@ -4177,7 +4173,7 @@ impl<'a, C, NC, A> ProjectTopicSubscriptionListCall<'a, C, NC, A> where NC: hype /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectTopicSubscriptionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectTopicSubscriptionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4198,7 +4194,7 @@ impl<'a, C, NC, A> ProjectTopicSubscriptionListCall<'a, C, NC, A> where NC: hype /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectTopicSubscriptionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectTopicSubscriptionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4215,7 +4211,7 @@ impl<'a, C, NC, A> ProjectTopicSubscriptionListCall<'a, C, NC, A> where NC: hype /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectTopicSubscriptionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectTopicSubscriptionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4255,10 +4251,10 @@ impl<'a, C, NC, A> ProjectTopicSubscriptionListCall<'a, C, NC, A> where NC: hype /// .doit(); /// # } /// ``` -pub struct ProjectSubscriptionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ProjectSubscriptionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Pubsub, + hub: &'a Pubsub, _project: String, _page_token: Option, _page_size: Option, @@ -4267,9 +4263,9 @@ pub struct ProjectSubscriptionListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ProjectSubscriptionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ProjectSubscriptionListCall<'a, C, A> {} -impl<'a, C, NC, A> ProjectSubscriptionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ProjectSubscriptionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4410,21 +4406,21 @@ impl<'a, C, NC, A> ProjectSubscriptionListCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn project(mut self, new_value: &str) -> ProjectSubscriptionListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ProjectSubscriptionListCall<'a, C, A> { self._project = new_value.to_string(); self } /// Sets the *page token* query property to the given value. /// /// - pub fn page_token(mut self, new_value: &str) -> ProjectSubscriptionListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ProjectSubscriptionListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } /// Sets the *page size* query property to the given value. /// /// - pub fn page_size(mut self, new_value: i32) -> ProjectSubscriptionListCall<'a, C, NC, A> { + pub fn page_size(mut self, new_value: i32) -> ProjectSubscriptionListCall<'a, C, A> { self._page_size = Some(new_value); self } @@ -4435,7 +4431,7 @@ impl<'a, C, NC, A> ProjectSubscriptionListCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectSubscriptionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ProjectSubscriptionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4456,7 +4452,7 @@ impl<'a, C, NC, A> ProjectSubscriptionListCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ProjectSubscriptionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ProjectSubscriptionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4473,7 +4469,7 @@ impl<'a, C, NC, A> ProjectSubscriptionListCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ProjectSubscriptionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ProjectSubscriptionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/qpxexpress1/Cargo.toml b/gen/qpxexpress1/Cargo.toml index 40a00484fd7..384290e6a8b 100644 --- a/gen/qpxexpress1/Cargo.toml +++ b/gen/qpxexpress1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-qpxexpress1" -version = "0.1.4+20140321" +version = "0.1.5+20140321" authors = ["Sebastian Thiel "] description = "A complete library to interact with QPX Express (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/qpxexpress1" homepage = "http://developers.google.com/qpx-express" -documentation = "http://byron.github.io/google-apis-rs/google-qpxexpress1" +documentation = "http://byron.github.io/google-apis-rs/google_qpxexpress1" license = "MIT" keywords = ["qpxExpress", "google", "protocol", "web", "api"] diff --git a/gen/qpxexpress1/README.md b/gen/qpxexpress1/README.md index 6adcf8e432b..d796918cb31 100644 --- a/gen/qpxexpress1/README.md +++ b/gen/qpxexpress1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-qpxexpress1` library allows access to all features of the *Google QPX Express* service. -This documentation was generated from *QPX Express* crate version *0.1.4+20140321*, where *20140321* is the exact revision of the *qpxExpress:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *QPX Express* crate version *0.1.5+20140321*, where *20140321* is the exact revision of the *qpxExpress:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *QPX Express* *v1* API can be found at the [official documentation site](http://developers.google.com/qpx-express). diff --git a/gen/qpxexpress1/src/cmn.rs b/gen/qpxexpress1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/qpxexpress1/src/cmn.rs +++ b/gen/qpxexpress1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/qpxexpress1/src/lib.rs b/gen/qpxexpress1/src/lib.rs index 8493dd2bd23..01ee52f1232 100644 --- a/gen/qpxexpress1/src/lib.rs +++ b/gen/qpxexpress1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *QPX Express* crate version *0.1.4+20140321*, where *20140321* is the exact revision of the *qpxExpress:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *QPX Express* crate version *0.1.5+20140321*, where *20140321* is the exact revision of the *qpxExpress:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *QPX Express* *v1* API can be found at the //! [official documentation site](http://developers.google.com/qpx-express). @@ -194,7 +194,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -269,34 +268,31 @@ pub use cmn::{MultiPartReader, ToParts, MethodInfo, Result, Error, CallBuilder, /// } /// # } /// ``` -pub struct QPXExpress { +pub struct QPXExpress { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for QPXExpress {} +impl<'a, C, A> Hub for QPXExpress {} -impl<'a, C, NC, A> QPXExpress - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> QPXExpress + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> QPXExpress { + pub fn new(client: C, authenticator: A) -> QPXExpress { QPXExpress { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn trips(&'a self) -> TripMethods<'a, C, NC, A> { + pub fn trips(&'a self) -> TripMethods<'a, C, A> { TripMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -936,15 +932,15 @@ impl Part for FreeBaggageAllowance {} /// let rb = hub.trips(); /// # } /// ``` -pub struct TripMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TripMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a QPXExpress, + hub: &'a QPXExpress, } -impl<'a, C, NC, A> MethodsBuilder for TripMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TripMethods<'a, C, A> {} -impl<'a, C, NC, A> TripMethods<'a, C, NC, A> { +impl<'a, C, A> TripMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -953,7 +949,7 @@ impl<'a, C, NC, A> TripMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn search(&self, request: &TripsSearchRequest) -> TripSearchCall<'a, C, NC, A> { + pub fn search(&self, request: &TripsSearchRequest) -> TripSearchCall<'a, C, A> { TripSearchCall { hub: self.hub, _request: request.clone(), @@ -1007,18 +1003,18 @@ impl<'a, C, NC, A> TripMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct TripSearchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TripSearchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a QPXExpress, + hub: &'a QPXExpress, _request: TripsSearchRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for TripSearchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TripSearchCall<'a, C, A> {} -impl<'a, C, NC, A> TripSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TripSearchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1130,7 +1126,7 @@ impl<'a, C, NC, A> TripSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &TripsSearchRequest) -> TripSearchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &TripsSearchRequest) -> TripSearchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1141,7 +1137,7 @@ impl<'a, C, NC, A> TripSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TripSearchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TripSearchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1162,7 +1158,7 @@ impl<'a, C, NC, A> TripSearchCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TripSearchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TripSearchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self diff --git a/gen/replicapool1_beta2/Cargo.toml b/gen/replicapool1_beta2/Cargo.toml index 8cc5dd0a13d..37e7550a1fa 100644 --- a/gen/replicapool1_beta2/Cargo.toml +++ b/gen/replicapool1_beta2/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-replicapool1_beta2" -version = "0.1.4+20150223" +version = "0.1.5+20150223" authors = ["Sebastian Thiel "] description = "A complete library to interact with replicapool (protocol v1beta2)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/replicapool1_beta2" homepage = "https://developers.google.com/compute/docs/instance-groups/manager/v1beta2" -documentation = "http://byron.github.io/google-apis-rs/google-replicapool1_beta2" +documentation = "http://byron.github.io/google-apis-rs/google_replicapool1_beta2" license = "MIT" keywords = ["replicapool", "google", "protocol", "web", "api"] diff --git a/gen/replicapool1_beta2/README.md b/gen/replicapool1_beta2/README.md index 6d3ec5a04ac..53a9c726ba4 100644 --- a/gen/replicapool1_beta2/README.md +++ b/gen/replicapool1_beta2/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-replicapool1_beta2` library allows access to all features of the *Google replicapool* service. -This documentation was generated from *replicapool* crate version *0.1.4+20150223*, where *20150223* is the exact revision of the *replicapool:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *replicapool* crate version *0.1.5+20150223*, where *20150223* is the exact revision of the *replicapool:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *replicapool* *v1_beta2* API can be found at the [official documentation site](https://developers.google.com/compute/docs/instance-groups/manager/v1beta2). diff --git a/gen/replicapool1_beta2/src/cmn.rs b/gen/replicapool1_beta2/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/replicapool1_beta2/src/cmn.rs +++ b/gen/replicapool1_beta2/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/replicapool1_beta2/src/lib.rs b/gen/replicapool1_beta2/src/lib.rs index 1df81cbabb7..86c4cdd8f85 100644 --- a/gen/replicapool1_beta2/src/lib.rs +++ b/gen/replicapool1_beta2/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *replicapool* crate version *0.1.4+20150223*, where *20150223* is the exact revision of the *replicapool:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *replicapool* crate version *0.1.5+20150223*, where *20150223* is the exact revision of the *replicapool:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *replicapool* *v1_beta2* API can be found at the //! [official documentation site](https://developers.google.com/compute/docs/instance-groups/manager/v1beta2). @@ -202,7 +202,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -304,37 +303,34 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Replicapool { +pub struct Replicapool { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Replicapool {} +impl<'a, C, A> Hub for Replicapool {} -impl<'a, C, NC, A> Replicapool - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Replicapool + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Replicapool { + pub fn new(client: C, authenticator: A) -> Replicapool { Replicapool { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn instance_group_managers(&'a self) -> InstanceGroupManagerMethods<'a, C, NC, A> { + pub fn instance_group_managers(&'a self) -> InstanceGroupManagerMethods<'a, C, A> { InstanceGroupManagerMethods { hub: &self } } - pub fn zone_operations(&'a self) -> ZoneOperationMethods<'a, C, NC, A> { + pub fn zone_operations(&'a self) -> ZoneOperationMethods<'a, C, A> { ZoneOperationMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -741,15 +737,15 @@ impl ResponseResult for Operation {} /// let rb = hub.zone_operations(); /// # } /// ``` -pub struct ZoneOperationMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneOperationMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapool, + hub: &'a Replicapool, } -impl<'a, C, NC, A> MethodsBuilder for ZoneOperationMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ZoneOperationMethods<'a, C, A> {} -impl<'a, C, NC, A> ZoneOperationMethods<'a, C, NC, A> { +impl<'a, C, A> ZoneOperationMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -759,7 +755,7 @@ impl<'a, C, NC, A> ZoneOperationMethods<'a, C, NC, A> { /// /// * `project` - Name of the project scoping this request. /// * `zone` - Name of the zone scoping this request. - pub fn list(&self, project: &str, zone: &str) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, zone: &str) -> ZoneOperationListCall<'a, C, A> { ZoneOperationListCall { hub: self.hub, _project: project.to_string(), @@ -782,7 +778,7 @@ impl<'a, C, NC, A> ZoneOperationMethods<'a, C, NC, A> { /// * `project` - Name of the project scoping this request. /// * `zone` - Name of the zone scoping this request. /// * `operation` - Name of the operation resource to return. - pub fn get(&self, project: &str, zone: &str, operation: &str) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, zone: &str, operation: &str) -> ZoneOperationGetCall<'a, C, A> { ZoneOperationGetCall { hub: self.hub, _project: project.to_string(), @@ -825,15 +821,15 @@ impl<'a, C, NC, A> ZoneOperationMethods<'a, C, NC, A> { /// let rb = hub.instance_group_managers(); /// # } /// ``` -pub struct InstanceGroupManagerMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceGroupManagerMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapool, + hub: &'a Replicapool, } -impl<'a, C, NC, A> MethodsBuilder for InstanceGroupManagerMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for InstanceGroupManagerMethods<'a, C, A> {} -impl<'a, C, NC, A> InstanceGroupManagerMethods<'a, C, NC, A> { +impl<'a, C, A> InstanceGroupManagerMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -845,7 +841,7 @@ impl<'a, C, NC, A> InstanceGroupManagerMethods<'a, C, NC, A> { /// * `project` - The Google Developers Console project name. /// * `zone` - The name of the zone in which the instance group manager resides. /// * `instanceGroupManager` - The name of the instance group manager. - pub fn set_target_pools(&self, request: &InstanceGroupManagersSetTargetPoolsRequest, project: &str, zone: &str, instance_group_manager: &str) -> InstanceGroupManagerSetTargetPoolCall<'a, C, NC, A> { + pub fn set_target_pools(&self, request: &InstanceGroupManagersSetTargetPoolsRequest, project: &str, zone: &str, instance_group_manager: &str) -> InstanceGroupManagerSetTargetPoolCall<'a, C, A> { InstanceGroupManagerSetTargetPoolCall { hub: self.hub, _request: request.clone(), @@ -866,7 +862,7 @@ impl<'a, C, NC, A> InstanceGroupManagerMethods<'a, C, NC, A> { /// /// * `project` - The Google Developers Console project name. /// * `zone` - The name of the zone in which the instance group manager resides. - pub fn list(&self, project: &str, zone: &str) -> InstanceGroupManagerListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, zone: &str) -> InstanceGroupManagerListCall<'a, C, A> { InstanceGroupManagerListCall { hub: self.hub, _project: project.to_string(), @@ -890,7 +886,7 @@ impl<'a, C, NC, A> InstanceGroupManagerMethods<'a, C, NC, A> { /// * `project` - The Google Developers Console project name. /// * `zone` - The name of the zone in which the instance group manager resides. /// * `size` - Number of instances that should exist. - pub fn insert(&self, request: &InstanceGroupManager, project: &str, zone: &str, size: i32) -> InstanceGroupManagerInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &InstanceGroupManager, project: &str, zone: &str, size: i32) -> InstanceGroupManagerInsertCall<'a, C, A> { InstanceGroupManagerInsertCall { hub: self.hub, _request: request.clone(), @@ -912,7 +908,7 @@ impl<'a, C, NC, A> InstanceGroupManagerMethods<'a, C, NC, A> { /// * `project` - The Google Developers Console project name. /// * `zone` - The name of the zone in which the instance group manager resides. /// * `instanceGroupManager` - Name of the instance resource to return. - pub fn get(&self, project: &str, zone: &str, instance_group_manager: &str) -> InstanceGroupManagerGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, zone: &str, instance_group_manager: &str) -> InstanceGroupManagerGetCall<'a, C, A> { InstanceGroupManagerGetCall { hub: self.hub, _project: project.to_string(), @@ -934,7 +930,7 @@ impl<'a, C, NC, A> InstanceGroupManagerMethods<'a, C, NC, A> { /// * `project` - The Google Developers Console project name. /// * `zone` - The name of the zone in which the instance group manager resides. /// * `instanceGroupManager` - The name of the instance group manager. - pub fn abandon_instances(&self, request: &InstanceGroupManagersAbandonInstancesRequest, project: &str, zone: &str, instance_group_manager: &str) -> InstanceGroupManagerAbandonInstanceCall<'a, C, NC, A> { + pub fn abandon_instances(&self, request: &InstanceGroupManagersAbandonInstancesRequest, project: &str, zone: &str, instance_group_manager: &str) -> InstanceGroupManagerAbandonInstanceCall<'a, C, A> { InstanceGroupManagerAbandonInstanceCall { hub: self.hub, _request: request.clone(), @@ -957,7 +953,7 @@ impl<'a, C, NC, A> InstanceGroupManagerMethods<'a, C, NC, A> { /// * `project` - The Google Developers Console project name. /// * `zone` - The name of the zone in which the instance group manager resides. /// * `instanceGroupManager` - The name of the instance group manager. - pub fn recreate_instances(&self, request: &InstanceGroupManagersRecreateInstancesRequest, project: &str, zone: &str, instance_group_manager: &str) -> InstanceGroupManagerRecreateInstanceCall<'a, C, NC, A> { + pub fn recreate_instances(&self, request: &InstanceGroupManagersRecreateInstancesRequest, project: &str, zone: &str, instance_group_manager: &str) -> InstanceGroupManagerRecreateInstanceCall<'a, C, A> { InstanceGroupManagerRecreateInstanceCall { hub: self.hub, _request: request.clone(), @@ -979,7 +975,7 @@ impl<'a, C, NC, A> InstanceGroupManagerMethods<'a, C, NC, A> { /// * `project` - The Google Developers Console project name. /// * `zone` - The name of the zone in which the instance group manager resides. /// * `instanceGroupManager` - Name of the Instance Group Manager resource to delete. - pub fn delete(&self, project: &str, zone: &str, instance_group_manager: &str) -> InstanceGroupManagerDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, zone: &str, instance_group_manager: &str) -> InstanceGroupManagerDeleteCall<'a, C, A> { InstanceGroupManagerDeleteCall { hub: self.hub, _project: project.to_string(), @@ -1001,7 +997,7 @@ impl<'a, C, NC, A> InstanceGroupManagerMethods<'a, C, NC, A> { /// * `project` - The Google Developers Console project name. /// * `zone` - The name of the zone in which the instance group manager resides. /// * `instanceGroupManager` - The name of the instance group manager. - pub fn set_instance_template(&self, request: &InstanceGroupManagersSetInstanceTemplateRequest, project: &str, zone: &str, instance_group_manager: &str) -> InstanceGroupManagerSetInstanceTemplateCall<'a, C, NC, A> { + pub fn set_instance_template(&self, request: &InstanceGroupManagersSetInstanceTemplateRequest, project: &str, zone: &str, instance_group_manager: &str) -> InstanceGroupManagerSetInstanceTemplateCall<'a, C, A> { InstanceGroupManagerSetInstanceTemplateCall { hub: self.hub, _request: request.clone(), @@ -1024,7 +1020,7 @@ impl<'a, C, NC, A> InstanceGroupManagerMethods<'a, C, NC, A> { /// * `zone` - The name of the zone in which the instance group manager resides. /// * `instanceGroupManager` - The name of the instance group manager. /// * `size` - Number of instances that should exist in this Instance Group Manager. - pub fn resize(&self, project: &str, zone: &str, instance_group_manager: &str, size: i32) -> InstanceGroupManagerResizeCall<'a, C, NC, A> { + pub fn resize(&self, project: &str, zone: &str, instance_group_manager: &str, size: i32) -> InstanceGroupManagerResizeCall<'a, C, A> { InstanceGroupManagerResizeCall { hub: self.hub, _project: project.to_string(), @@ -1047,7 +1043,7 @@ impl<'a, C, NC, A> InstanceGroupManagerMethods<'a, C, NC, A> { /// * `project` - The Google Developers Console project name. /// * `zone` - The name of the zone in which the instance group manager resides. /// * `instanceGroupManager` - The name of the instance group manager. - pub fn delete_instances(&self, request: &InstanceGroupManagersDeleteInstancesRequest, project: &str, zone: &str, instance_group_manager: &str) -> InstanceGroupManagerDeleteInstanceCall<'a, C, NC, A> { + pub fn delete_instances(&self, request: &InstanceGroupManagersDeleteInstancesRequest, project: &str, zone: &str, instance_group_manager: &str) -> InstanceGroupManagerDeleteInstanceCall<'a, C, A> { InstanceGroupManagerDeleteInstanceCall { hub: self.hub, _request: request.clone(), @@ -1102,10 +1098,10 @@ impl<'a, C, NC, A> InstanceGroupManagerMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct ZoneOperationListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneOperationListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapool, + hub: &'a Replicapool, _project: String, _zone: String, _page_token: Option, @@ -1116,9 +1112,9 @@ pub struct ZoneOperationListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ZoneOperationListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ZoneOperationListCall<'a, C, A> {} -impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ZoneOperationListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1260,7 +1256,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1270,7 +1266,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Name of the zone scoping this request. - pub fn zone(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -1278,7 +1274,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -1286,7 +1282,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> ZoneOperationListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -1294,7 +1290,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -1305,7 +1301,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneOperationListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1326,7 +1322,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ZoneOperationListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ZoneOperationListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1343,7 +1339,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ZoneOperationListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ZoneOperationListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1381,10 +1377,10 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct ZoneOperationGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneOperationGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapool, + hub: &'a Replicapool, _project: String, _zone: String, _operation: String, @@ -1393,9 +1389,9 @@ pub struct ZoneOperationGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ZoneOperationGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ZoneOperationGetCall<'a, C, A> {} -impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ZoneOperationGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1529,7 +1525,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1539,7 +1535,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Name of the zone scoping this request. - pub fn zone(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -1549,7 +1545,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Name of the operation resource to return. - pub fn operation(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn operation(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, A> { self._operation = new_value.to_string(); self } @@ -1560,7 +1556,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneOperationGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1581,7 +1577,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ZoneOperationGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ZoneOperationGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1598,7 +1594,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ZoneOperationGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ZoneOperationGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1642,10 +1638,10 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct InstanceGroupManagerSetTargetPoolCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceGroupManagerSetTargetPoolCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapool, + hub: &'a Replicapool, _request: InstanceGroupManagersSetTargetPoolsRequest, _project: String, _zone: String, @@ -1655,9 +1651,9 @@ pub struct InstanceGroupManagerSetTargetPoolCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceGroupManagerSetTargetPoolCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceGroupManagerSetTargetPoolCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceGroupManagerSetTargetPoolCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceGroupManagerSetTargetPoolCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1798,7 +1794,7 @@ impl<'a, C, NC, A> InstanceGroupManagerSetTargetPoolCall<'a, C, NC, A> where NC: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &InstanceGroupManagersSetTargetPoolsRequest) -> InstanceGroupManagerSetTargetPoolCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &InstanceGroupManagersSetTargetPoolsRequest) -> InstanceGroupManagerSetTargetPoolCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1808,7 +1804,7 @@ impl<'a, C, NC, A> InstanceGroupManagerSetTargetPoolCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// The Google Developers Console project name. - pub fn project(mut self, new_value: &str) -> InstanceGroupManagerSetTargetPoolCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceGroupManagerSetTargetPoolCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1818,7 +1814,7 @@ impl<'a, C, NC, A> InstanceGroupManagerSetTargetPoolCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// The name of the zone in which the instance group manager resides. - pub fn zone(mut self, new_value: &str) -> InstanceGroupManagerSetTargetPoolCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceGroupManagerSetTargetPoolCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -1828,7 +1824,7 @@ impl<'a, C, NC, A> InstanceGroupManagerSetTargetPoolCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// The name of the instance group manager. - pub fn instance_group_manager(mut self, new_value: &str) -> InstanceGroupManagerSetTargetPoolCall<'a, C, NC, A> { + pub fn instance_group_manager(mut self, new_value: &str) -> InstanceGroupManagerSetTargetPoolCall<'a, C, A> { self._instance_group_manager = new_value.to_string(); self } @@ -1839,7 +1835,7 @@ impl<'a, C, NC, A> InstanceGroupManagerSetTargetPoolCall<'a, C, NC, A> where NC: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGroupManagerSetTargetPoolCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGroupManagerSetTargetPoolCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1860,7 +1856,7 @@ impl<'a, C, NC, A> InstanceGroupManagerSetTargetPoolCall<'a, C, NC, A> where NC: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceGroupManagerSetTargetPoolCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceGroupManagerSetTargetPoolCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1877,7 +1873,7 @@ impl<'a, C, NC, A> InstanceGroupManagerSetTargetPoolCall<'a, C, NC, A> where NC: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceGroupManagerSetTargetPoolCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceGroupManagerSetTargetPoolCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1918,10 +1914,10 @@ impl<'a, C, NC, A> InstanceGroupManagerSetTargetPoolCall<'a, C, NC, A> where NC: /// .doit(); /// # } /// ``` -pub struct InstanceGroupManagerListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceGroupManagerListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapool, + hub: &'a Replicapool, _project: String, _zone: String, _page_token: Option, @@ -1932,9 +1928,9 @@ pub struct InstanceGroupManagerListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceGroupManagerListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceGroupManagerListCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceGroupManagerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceGroupManagerListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2076,7 +2072,7 @@ impl<'a, C, NC, A> InstanceGroupManagerListCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The Google Developers Console project name. - pub fn project(mut self, new_value: &str) -> InstanceGroupManagerListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceGroupManagerListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2086,7 +2082,7 @@ impl<'a, C, NC, A> InstanceGroupManagerListCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The name of the zone in which the instance group manager resides. - pub fn zone(mut self, new_value: &str) -> InstanceGroupManagerListCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceGroupManagerListCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -2094,7 +2090,7 @@ impl<'a, C, NC, A> InstanceGroupManagerListCall<'a, C, NC, A> where NC: hyper::n /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> InstanceGroupManagerListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> InstanceGroupManagerListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2102,7 +2098,7 @@ impl<'a, C, NC, A> InstanceGroupManagerListCall<'a, C, NC, A> where NC: hyper::n /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> InstanceGroupManagerListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> InstanceGroupManagerListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2110,7 +2106,7 @@ impl<'a, C, NC, A> InstanceGroupManagerListCall<'a, C, NC, A> where NC: hyper::n /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> InstanceGroupManagerListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> InstanceGroupManagerListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -2121,7 +2117,7 @@ impl<'a, C, NC, A> InstanceGroupManagerListCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGroupManagerListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGroupManagerListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2142,7 +2138,7 @@ impl<'a, C, NC, A> InstanceGroupManagerListCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceGroupManagerListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceGroupManagerListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2159,7 +2155,7 @@ impl<'a, C, NC, A> InstanceGroupManagerListCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceGroupManagerListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceGroupManagerListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2203,10 +2199,10 @@ impl<'a, C, NC, A> InstanceGroupManagerListCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct InstanceGroupManagerInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceGroupManagerInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapool, + hub: &'a Replicapool, _request: InstanceGroupManager, _project: String, _zone: String, @@ -2216,9 +2212,9 @@ pub struct InstanceGroupManagerInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceGroupManagerInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceGroupManagerInsertCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceGroupManagerInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceGroupManagerInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2359,7 +2355,7 @@ impl<'a, C, NC, A> InstanceGroupManagerInsertCall<'a, C, NC, A> where NC: hyper: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &InstanceGroupManager) -> InstanceGroupManagerInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &InstanceGroupManager) -> InstanceGroupManagerInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2369,7 +2365,7 @@ impl<'a, C, NC, A> InstanceGroupManagerInsertCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The Google Developers Console project name. - pub fn project(mut self, new_value: &str) -> InstanceGroupManagerInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceGroupManagerInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2379,7 +2375,7 @@ impl<'a, C, NC, A> InstanceGroupManagerInsertCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The name of the zone in which the instance group manager resides. - pub fn zone(mut self, new_value: &str) -> InstanceGroupManagerInsertCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceGroupManagerInsertCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -2389,7 +2385,7 @@ impl<'a, C, NC, A> InstanceGroupManagerInsertCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Number of instances that should exist. - pub fn size(mut self, new_value: i32) -> InstanceGroupManagerInsertCall<'a, C, NC, A> { + pub fn size(mut self, new_value: i32) -> InstanceGroupManagerInsertCall<'a, C, A> { self._size = new_value; self } @@ -2400,7 +2396,7 @@ impl<'a, C, NC, A> InstanceGroupManagerInsertCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGroupManagerInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGroupManagerInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2421,7 +2417,7 @@ impl<'a, C, NC, A> InstanceGroupManagerInsertCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceGroupManagerInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceGroupManagerInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2438,7 +2434,7 @@ impl<'a, C, NC, A> InstanceGroupManagerInsertCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceGroupManagerInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceGroupManagerInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2476,10 +2472,10 @@ impl<'a, C, NC, A> InstanceGroupManagerInsertCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct InstanceGroupManagerGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceGroupManagerGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapool, + hub: &'a Replicapool, _project: String, _zone: String, _instance_group_manager: String, @@ -2488,9 +2484,9 @@ pub struct InstanceGroupManagerGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceGroupManagerGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceGroupManagerGetCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceGroupManagerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceGroupManagerGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2624,7 +2620,7 @@ impl<'a, C, NC, A> InstanceGroupManagerGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The Google Developers Console project name. - pub fn project(mut self, new_value: &str) -> InstanceGroupManagerGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceGroupManagerGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2634,7 +2630,7 @@ impl<'a, C, NC, A> InstanceGroupManagerGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The name of the zone in which the instance group manager resides. - pub fn zone(mut self, new_value: &str) -> InstanceGroupManagerGetCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceGroupManagerGetCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -2644,7 +2640,7 @@ impl<'a, C, NC, A> InstanceGroupManagerGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Name of the instance resource to return. - pub fn instance_group_manager(mut self, new_value: &str) -> InstanceGroupManagerGetCall<'a, C, NC, A> { + pub fn instance_group_manager(mut self, new_value: &str) -> InstanceGroupManagerGetCall<'a, C, A> { self._instance_group_manager = new_value.to_string(); self } @@ -2655,7 +2651,7 @@ impl<'a, C, NC, A> InstanceGroupManagerGetCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGroupManagerGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGroupManagerGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2676,7 +2672,7 @@ impl<'a, C, NC, A> InstanceGroupManagerGetCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceGroupManagerGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceGroupManagerGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2693,7 +2689,7 @@ impl<'a, C, NC, A> InstanceGroupManagerGetCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceGroupManagerGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceGroupManagerGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2737,10 +2733,10 @@ impl<'a, C, NC, A> InstanceGroupManagerGetCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct InstanceGroupManagerAbandonInstanceCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceGroupManagerAbandonInstanceCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapool, + hub: &'a Replicapool, _request: InstanceGroupManagersAbandonInstancesRequest, _project: String, _zone: String, @@ -2750,9 +2746,9 @@ pub struct InstanceGroupManagerAbandonInstanceCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceGroupManagerAbandonInstanceCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceGroupManagerAbandonInstanceCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceGroupManagerAbandonInstanceCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceGroupManagerAbandonInstanceCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2893,7 +2889,7 @@ impl<'a, C, NC, A> InstanceGroupManagerAbandonInstanceCall<'a, C, NC, A> where N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &InstanceGroupManagersAbandonInstancesRequest) -> InstanceGroupManagerAbandonInstanceCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &InstanceGroupManagersAbandonInstancesRequest) -> InstanceGroupManagerAbandonInstanceCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2903,7 +2899,7 @@ impl<'a, C, NC, A> InstanceGroupManagerAbandonInstanceCall<'a, C, NC, A> where N /// we provide this method for API completeness. /// /// The Google Developers Console project name. - pub fn project(mut self, new_value: &str) -> InstanceGroupManagerAbandonInstanceCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceGroupManagerAbandonInstanceCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2913,7 +2909,7 @@ impl<'a, C, NC, A> InstanceGroupManagerAbandonInstanceCall<'a, C, NC, A> where N /// we provide this method for API completeness. /// /// The name of the zone in which the instance group manager resides. - pub fn zone(mut self, new_value: &str) -> InstanceGroupManagerAbandonInstanceCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceGroupManagerAbandonInstanceCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -2923,7 +2919,7 @@ impl<'a, C, NC, A> InstanceGroupManagerAbandonInstanceCall<'a, C, NC, A> where N /// we provide this method for API completeness. /// /// The name of the instance group manager. - pub fn instance_group_manager(mut self, new_value: &str) -> InstanceGroupManagerAbandonInstanceCall<'a, C, NC, A> { + pub fn instance_group_manager(mut self, new_value: &str) -> InstanceGroupManagerAbandonInstanceCall<'a, C, A> { self._instance_group_manager = new_value.to_string(); self } @@ -2934,7 +2930,7 @@ impl<'a, C, NC, A> InstanceGroupManagerAbandonInstanceCall<'a, C, NC, A> where N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGroupManagerAbandonInstanceCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGroupManagerAbandonInstanceCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2955,7 +2951,7 @@ impl<'a, C, NC, A> InstanceGroupManagerAbandonInstanceCall<'a, C, NC, A> where N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceGroupManagerAbandonInstanceCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceGroupManagerAbandonInstanceCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2972,7 +2968,7 @@ impl<'a, C, NC, A> InstanceGroupManagerAbandonInstanceCall<'a, C, NC, A> where N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceGroupManagerAbandonInstanceCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceGroupManagerAbandonInstanceCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3016,10 +3012,10 @@ impl<'a, C, NC, A> InstanceGroupManagerAbandonInstanceCall<'a, C, NC, A> where N /// .doit(); /// # } /// ``` -pub struct InstanceGroupManagerRecreateInstanceCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceGroupManagerRecreateInstanceCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapool, + hub: &'a Replicapool, _request: InstanceGroupManagersRecreateInstancesRequest, _project: String, _zone: String, @@ -3029,9 +3025,9 @@ pub struct InstanceGroupManagerRecreateInstanceCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceGroupManagerRecreateInstanceCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceGroupManagerRecreateInstanceCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceGroupManagerRecreateInstanceCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceGroupManagerRecreateInstanceCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3172,7 +3168,7 @@ impl<'a, C, NC, A> InstanceGroupManagerRecreateInstanceCall<'a, C, NC, A> where /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &InstanceGroupManagersRecreateInstancesRequest) -> InstanceGroupManagerRecreateInstanceCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &InstanceGroupManagersRecreateInstancesRequest) -> InstanceGroupManagerRecreateInstanceCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3182,7 +3178,7 @@ impl<'a, C, NC, A> InstanceGroupManagerRecreateInstanceCall<'a, C, NC, A> where /// we provide this method for API completeness. /// /// The Google Developers Console project name. - pub fn project(mut self, new_value: &str) -> InstanceGroupManagerRecreateInstanceCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceGroupManagerRecreateInstanceCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -3192,7 +3188,7 @@ impl<'a, C, NC, A> InstanceGroupManagerRecreateInstanceCall<'a, C, NC, A> where /// we provide this method for API completeness. /// /// The name of the zone in which the instance group manager resides. - pub fn zone(mut self, new_value: &str) -> InstanceGroupManagerRecreateInstanceCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceGroupManagerRecreateInstanceCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -3202,7 +3198,7 @@ impl<'a, C, NC, A> InstanceGroupManagerRecreateInstanceCall<'a, C, NC, A> where /// we provide this method for API completeness. /// /// The name of the instance group manager. - pub fn instance_group_manager(mut self, new_value: &str) -> InstanceGroupManagerRecreateInstanceCall<'a, C, NC, A> { + pub fn instance_group_manager(mut self, new_value: &str) -> InstanceGroupManagerRecreateInstanceCall<'a, C, A> { self._instance_group_manager = new_value.to_string(); self } @@ -3213,7 +3209,7 @@ impl<'a, C, NC, A> InstanceGroupManagerRecreateInstanceCall<'a, C, NC, A> where /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGroupManagerRecreateInstanceCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGroupManagerRecreateInstanceCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3234,7 +3230,7 @@ impl<'a, C, NC, A> InstanceGroupManagerRecreateInstanceCall<'a, C, NC, A> where /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceGroupManagerRecreateInstanceCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceGroupManagerRecreateInstanceCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3251,7 +3247,7 @@ impl<'a, C, NC, A> InstanceGroupManagerRecreateInstanceCall<'a, C, NC, A> where /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceGroupManagerRecreateInstanceCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceGroupManagerRecreateInstanceCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3289,10 +3285,10 @@ impl<'a, C, NC, A> InstanceGroupManagerRecreateInstanceCall<'a, C, NC, A> where /// .doit(); /// # } /// ``` -pub struct InstanceGroupManagerDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceGroupManagerDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapool, + hub: &'a Replicapool, _project: String, _zone: String, _instance_group_manager: String, @@ -3301,9 +3297,9 @@ pub struct InstanceGroupManagerDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceGroupManagerDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceGroupManagerDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceGroupManagerDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceGroupManagerDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3437,7 +3433,7 @@ impl<'a, C, NC, A> InstanceGroupManagerDeleteCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The Google Developers Console project name. - pub fn project(mut self, new_value: &str) -> InstanceGroupManagerDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceGroupManagerDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -3447,7 +3443,7 @@ impl<'a, C, NC, A> InstanceGroupManagerDeleteCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The name of the zone in which the instance group manager resides. - pub fn zone(mut self, new_value: &str) -> InstanceGroupManagerDeleteCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceGroupManagerDeleteCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -3457,7 +3453,7 @@ impl<'a, C, NC, A> InstanceGroupManagerDeleteCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Name of the Instance Group Manager resource to delete. - pub fn instance_group_manager(mut self, new_value: &str) -> InstanceGroupManagerDeleteCall<'a, C, NC, A> { + pub fn instance_group_manager(mut self, new_value: &str) -> InstanceGroupManagerDeleteCall<'a, C, A> { self._instance_group_manager = new_value.to_string(); self } @@ -3468,7 +3464,7 @@ impl<'a, C, NC, A> InstanceGroupManagerDeleteCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGroupManagerDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGroupManagerDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3489,7 +3485,7 @@ impl<'a, C, NC, A> InstanceGroupManagerDeleteCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceGroupManagerDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceGroupManagerDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3506,7 +3502,7 @@ impl<'a, C, NC, A> InstanceGroupManagerDeleteCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceGroupManagerDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceGroupManagerDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3550,10 +3546,10 @@ impl<'a, C, NC, A> InstanceGroupManagerDeleteCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct InstanceGroupManagerSetInstanceTemplateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceGroupManagerSetInstanceTemplateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapool, + hub: &'a Replicapool, _request: InstanceGroupManagersSetInstanceTemplateRequest, _project: String, _zone: String, @@ -3563,9 +3559,9 @@ pub struct InstanceGroupManagerSetInstanceTemplateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceGroupManagerSetInstanceTemplateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceGroupManagerSetInstanceTemplateCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceGroupManagerSetInstanceTemplateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceGroupManagerSetInstanceTemplateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3706,7 +3702,7 @@ impl<'a, C, NC, A> InstanceGroupManagerSetInstanceTemplateCall<'a, C, NC, A> whe /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &InstanceGroupManagersSetInstanceTemplateRequest) -> InstanceGroupManagerSetInstanceTemplateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &InstanceGroupManagersSetInstanceTemplateRequest) -> InstanceGroupManagerSetInstanceTemplateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3716,7 +3712,7 @@ impl<'a, C, NC, A> InstanceGroupManagerSetInstanceTemplateCall<'a, C, NC, A> whe /// we provide this method for API completeness. /// /// The Google Developers Console project name. - pub fn project(mut self, new_value: &str) -> InstanceGroupManagerSetInstanceTemplateCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceGroupManagerSetInstanceTemplateCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -3726,7 +3722,7 @@ impl<'a, C, NC, A> InstanceGroupManagerSetInstanceTemplateCall<'a, C, NC, A> whe /// we provide this method for API completeness. /// /// The name of the zone in which the instance group manager resides. - pub fn zone(mut self, new_value: &str) -> InstanceGroupManagerSetInstanceTemplateCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceGroupManagerSetInstanceTemplateCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -3736,7 +3732,7 @@ impl<'a, C, NC, A> InstanceGroupManagerSetInstanceTemplateCall<'a, C, NC, A> whe /// we provide this method for API completeness. /// /// The name of the instance group manager. - pub fn instance_group_manager(mut self, new_value: &str) -> InstanceGroupManagerSetInstanceTemplateCall<'a, C, NC, A> { + pub fn instance_group_manager(mut self, new_value: &str) -> InstanceGroupManagerSetInstanceTemplateCall<'a, C, A> { self._instance_group_manager = new_value.to_string(); self } @@ -3747,7 +3743,7 @@ impl<'a, C, NC, A> InstanceGroupManagerSetInstanceTemplateCall<'a, C, NC, A> whe /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGroupManagerSetInstanceTemplateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGroupManagerSetInstanceTemplateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3768,7 +3764,7 @@ impl<'a, C, NC, A> InstanceGroupManagerSetInstanceTemplateCall<'a, C, NC, A> whe /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceGroupManagerSetInstanceTemplateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceGroupManagerSetInstanceTemplateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3785,7 +3781,7 @@ impl<'a, C, NC, A> InstanceGroupManagerSetInstanceTemplateCall<'a, C, NC, A> whe /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceGroupManagerSetInstanceTemplateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceGroupManagerSetInstanceTemplateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3823,10 +3819,10 @@ impl<'a, C, NC, A> InstanceGroupManagerSetInstanceTemplateCall<'a, C, NC, A> whe /// .doit(); /// # } /// ``` -pub struct InstanceGroupManagerResizeCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceGroupManagerResizeCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapool, + hub: &'a Replicapool, _project: String, _zone: String, _instance_group_manager: String, @@ -3836,9 +3832,9 @@ pub struct InstanceGroupManagerResizeCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceGroupManagerResizeCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceGroupManagerResizeCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceGroupManagerResizeCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceGroupManagerResizeCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3973,7 +3969,7 @@ impl<'a, C, NC, A> InstanceGroupManagerResizeCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The Google Developers Console project name. - pub fn project(mut self, new_value: &str) -> InstanceGroupManagerResizeCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceGroupManagerResizeCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -3983,7 +3979,7 @@ impl<'a, C, NC, A> InstanceGroupManagerResizeCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The name of the zone in which the instance group manager resides. - pub fn zone(mut self, new_value: &str) -> InstanceGroupManagerResizeCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceGroupManagerResizeCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -3993,7 +3989,7 @@ impl<'a, C, NC, A> InstanceGroupManagerResizeCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The name of the instance group manager. - pub fn instance_group_manager(mut self, new_value: &str) -> InstanceGroupManagerResizeCall<'a, C, NC, A> { + pub fn instance_group_manager(mut self, new_value: &str) -> InstanceGroupManagerResizeCall<'a, C, A> { self._instance_group_manager = new_value.to_string(); self } @@ -4003,7 +3999,7 @@ impl<'a, C, NC, A> InstanceGroupManagerResizeCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// Number of instances that should exist in this Instance Group Manager. - pub fn size(mut self, new_value: i32) -> InstanceGroupManagerResizeCall<'a, C, NC, A> { + pub fn size(mut self, new_value: i32) -> InstanceGroupManagerResizeCall<'a, C, A> { self._size = new_value; self } @@ -4014,7 +4010,7 @@ impl<'a, C, NC, A> InstanceGroupManagerResizeCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGroupManagerResizeCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGroupManagerResizeCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4035,7 +4031,7 @@ impl<'a, C, NC, A> InstanceGroupManagerResizeCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceGroupManagerResizeCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceGroupManagerResizeCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4052,7 +4048,7 @@ impl<'a, C, NC, A> InstanceGroupManagerResizeCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceGroupManagerResizeCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceGroupManagerResizeCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4096,10 +4092,10 @@ impl<'a, C, NC, A> InstanceGroupManagerResizeCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct InstanceGroupManagerDeleteInstanceCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceGroupManagerDeleteInstanceCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapool, + hub: &'a Replicapool, _request: InstanceGroupManagersDeleteInstancesRequest, _project: String, _zone: String, @@ -4109,9 +4105,9 @@ pub struct InstanceGroupManagerDeleteInstanceCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceGroupManagerDeleteInstanceCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceGroupManagerDeleteInstanceCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceGroupManagerDeleteInstanceCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceGroupManagerDeleteInstanceCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4252,7 +4248,7 @@ impl<'a, C, NC, A> InstanceGroupManagerDeleteInstanceCall<'a, C, NC, A> where NC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &InstanceGroupManagersDeleteInstancesRequest) -> InstanceGroupManagerDeleteInstanceCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &InstanceGroupManagersDeleteInstancesRequest) -> InstanceGroupManagerDeleteInstanceCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4262,7 +4258,7 @@ impl<'a, C, NC, A> InstanceGroupManagerDeleteInstanceCall<'a, C, NC, A> where NC /// we provide this method for API completeness. /// /// The Google Developers Console project name. - pub fn project(mut self, new_value: &str) -> InstanceGroupManagerDeleteInstanceCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceGroupManagerDeleteInstanceCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -4272,7 +4268,7 @@ impl<'a, C, NC, A> InstanceGroupManagerDeleteInstanceCall<'a, C, NC, A> where NC /// we provide this method for API completeness. /// /// The name of the zone in which the instance group manager resides. - pub fn zone(mut self, new_value: &str) -> InstanceGroupManagerDeleteInstanceCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> InstanceGroupManagerDeleteInstanceCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -4282,7 +4278,7 @@ impl<'a, C, NC, A> InstanceGroupManagerDeleteInstanceCall<'a, C, NC, A> where NC /// we provide this method for API completeness. /// /// The name of the instance group manager. - pub fn instance_group_manager(mut self, new_value: &str) -> InstanceGroupManagerDeleteInstanceCall<'a, C, NC, A> { + pub fn instance_group_manager(mut self, new_value: &str) -> InstanceGroupManagerDeleteInstanceCall<'a, C, A> { self._instance_group_manager = new_value.to_string(); self } @@ -4293,7 +4289,7 @@ impl<'a, C, NC, A> InstanceGroupManagerDeleteInstanceCall<'a, C, NC, A> where NC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGroupManagerDeleteInstanceCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGroupManagerDeleteInstanceCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4314,7 +4310,7 @@ impl<'a, C, NC, A> InstanceGroupManagerDeleteInstanceCall<'a, C, NC, A> where NC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceGroupManagerDeleteInstanceCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceGroupManagerDeleteInstanceCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4331,7 +4327,7 @@ impl<'a, C, NC, A> InstanceGroupManagerDeleteInstanceCall<'a, C, NC, A> where NC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceGroupManagerDeleteInstanceCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceGroupManagerDeleteInstanceCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/replicapoolupdater1_beta1/Cargo.toml b/gen/replicapoolupdater1_beta1/Cargo.toml index 13c8387f9da..37f4388bca5 100644 --- a/gen/replicapoolupdater1_beta1/Cargo.toml +++ b/gen/replicapoolupdater1_beta1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-replicapoolupdater1_beta1" -version = "0.1.4+20150129" +version = "0.1.5+20150129" authors = ["Sebastian Thiel "] description = "A complete library to interact with replicapoolupdater (protocol v1beta1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/replicapoolupdater1_beta1" homepage = "https://cloud.google.com/compute/docs/instance-groups/manager/#applying_rolling_updates_using_the_updater_service" -documentation = "http://byron.github.io/google-apis-rs/google-replicapoolupdater1_beta1" +documentation = "http://byron.github.io/google-apis-rs/google_replicapoolupdater1_beta1" license = "MIT" keywords = ["replicapoolupdater", "google", "protocol", "web", "api"] diff --git a/gen/replicapoolupdater1_beta1/README.md b/gen/replicapoolupdater1_beta1/README.md index 4631f2ff787..c8c08e03ccf 100644 --- a/gen/replicapoolupdater1_beta1/README.md +++ b/gen/replicapoolupdater1_beta1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-replicapoolupdater1_beta1` library allows access to all features of the *Google replicapoolupdater* service. -This documentation was generated from *replicapoolupdater* crate version *0.1.4+20150129*, where *20150129* is the exact revision of the *replicapoolupdater:v1beta1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *replicapoolupdater* crate version *0.1.5+20150129*, where *20150129* is the exact revision of the *replicapoolupdater:v1beta1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *replicapoolupdater* *v1_beta1* API can be found at the [official documentation site](https://cloud.google.com/compute/docs/instance-groups/manager/#applying_rolling_updates_using_the_updater_service). diff --git a/gen/replicapoolupdater1_beta1/src/cmn.rs b/gen/replicapoolupdater1_beta1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/replicapoolupdater1_beta1/src/cmn.rs +++ b/gen/replicapoolupdater1_beta1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/replicapoolupdater1_beta1/src/lib.rs b/gen/replicapoolupdater1_beta1/src/lib.rs index 03f2f589d00..43b309238c0 100644 --- a/gen/replicapoolupdater1_beta1/src/lib.rs +++ b/gen/replicapoolupdater1_beta1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *replicapoolupdater* crate version *0.1.4+20150129*, where *20150129* is the exact revision of the *replicapoolupdater:v1beta1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *replicapoolupdater* crate version *0.1.5+20150129*, where *20150129* is the exact revision of the *replicapoolupdater:v1beta1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *replicapoolupdater* *v1_beta1* API can be found at the //! [official documentation site](https://cloud.google.com/compute/docs/instance-groups/manager/#applying_rolling_updates_using_the_updater_service). @@ -201,7 +201,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -304,37 +303,34 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Replicapoolupdater { +pub struct Replicapoolupdater { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Replicapoolupdater {} +impl<'a, C, A> Hub for Replicapoolupdater {} -impl<'a, C, NC, A> Replicapoolupdater - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Replicapoolupdater + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Replicapoolupdater { + pub fn new(client: C, authenticator: A) -> Replicapoolupdater { Replicapoolupdater { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn rolling_updates(&'a self) -> RollingUpdateMethods<'a, C, NC, A> { + pub fn rolling_updates(&'a self) -> RollingUpdateMethods<'a, C, A> { RollingUpdateMethods { hub: &self } } - pub fn zone_operations(&'a self) -> ZoneOperationMethods<'a, C, NC, A> { + pub fn zone_operations(&'a self) -> ZoneOperationMethods<'a, C, A> { ZoneOperationMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -764,15 +760,15 @@ impl ResponseResult for RollingUpdateList {} /// let rb = hub.rolling_updates(); /// # } /// ``` -pub struct RollingUpdateMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RollingUpdateMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapoolupdater, + hub: &'a Replicapoolupdater, } -impl<'a, C, NC, A> MethodsBuilder for RollingUpdateMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for RollingUpdateMethods<'a, C, A> {} -impl<'a, C, NC, A> RollingUpdateMethods<'a, C, NC, A> { +impl<'a, C, A> RollingUpdateMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -783,7 +779,7 @@ impl<'a, C, NC, A> RollingUpdateMethods<'a, C, NC, A> { /// * `project` - The Google Developers Console project name. /// * `zone` - The name of the zone in which the update's target resides. /// * `rollingUpdate` - The name of the update. - pub fn pause(&self, project: &str, zone: &str, rolling_update: &str) -> RollingUpdatePauseCall<'a, C, NC, A> { + pub fn pause(&self, project: &str, zone: &str, rolling_update: &str) -> RollingUpdatePauseCall<'a, C, A> { RollingUpdatePauseCall { hub: self.hub, _project: project.to_string(), @@ -804,7 +800,7 @@ impl<'a, C, NC, A> RollingUpdateMethods<'a, C, NC, A> { /// * `project` - The Google Developers Console project name. /// * `zone` - The name of the zone in which the update's target resides. /// * `rollingUpdate` - The name of the update. - pub fn rollback(&self, project: &str, zone: &str, rolling_update: &str) -> RollingUpdateRollbackCall<'a, C, NC, A> { + pub fn rollback(&self, project: &str, zone: &str, rolling_update: &str) -> RollingUpdateRollbackCall<'a, C, A> { RollingUpdateRollbackCall { hub: self.hub, _project: project.to_string(), @@ -825,7 +821,7 @@ impl<'a, C, NC, A> RollingUpdateMethods<'a, C, NC, A> { /// * `project` - The Google Developers Console project name. /// * `zone` - The name of the zone in which the update's target resides. /// * `rollingUpdate` - The name of the update. - pub fn get(&self, project: &str, zone: &str, rolling_update: &str) -> RollingUpdateGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, zone: &str, rolling_update: &str) -> RollingUpdateGetCall<'a, C, A> { RollingUpdateGetCall { hub: self.hub, _project: project.to_string(), @@ -846,7 +842,7 @@ impl<'a, C, NC, A> RollingUpdateMethods<'a, C, NC, A> { /// * `project` - The Google Developers Console project name. /// * `zone` - The name of the zone in which the update's target resides. /// * `rollingUpdate` - The name of the update. - pub fn resume(&self, project: &str, zone: &str, rolling_update: &str) -> RollingUpdateResumeCall<'a, C, NC, A> { + pub fn resume(&self, project: &str, zone: &str, rolling_update: &str) -> RollingUpdateResumeCall<'a, C, A> { RollingUpdateResumeCall { hub: self.hub, _project: project.to_string(), @@ -866,7 +862,7 @@ impl<'a, C, NC, A> RollingUpdateMethods<'a, C, NC, A> { /// /// * `project` - The Google Developers Console project name. /// * `zone` - The name of the zone in which the update's target resides. - pub fn list(&self, project: &str, zone: &str) -> RollingUpdateListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, zone: &str) -> RollingUpdateListCall<'a, C, A> { RollingUpdateListCall { hub: self.hub, _project: project.to_string(), @@ -890,7 +886,7 @@ impl<'a, C, NC, A> RollingUpdateMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - The Google Developers Console project name. /// * `zone` - The name of the zone in which the update's target resides. - pub fn insert(&self, request: &RollingUpdate, project: &str, zone: &str) -> RollingUpdateInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &RollingUpdate, project: &str, zone: &str) -> RollingUpdateInsertCall<'a, C, A> { RollingUpdateInsertCall { hub: self.hub, _request: request.clone(), @@ -911,7 +907,7 @@ impl<'a, C, NC, A> RollingUpdateMethods<'a, C, NC, A> { /// * `project` - The Google Developers Console project name. /// * `zone` - The name of the zone in which the update's target resides. /// * `rollingUpdate` - The name of the update. - pub fn list_instance_updates(&self, project: &str, zone: &str, rolling_update: &str) -> RollingUpdateListInstanceUpdateCall<'a, C, NC, A> { + pub fn list_instance_updates(&self, project: &str, zone: &str, rolling_update: &str) -> RollingUpdateListInstanceUpdateCall<'a, C, A> { RollingUpdateListInstanceUpdateCall { hub: self.hub, _project: project.to_string(), @@ -935,7 +931,7 @@ impl<'a, C, NC, A> RollingUpdateMethods<'a, C, NC, A> { /// * `project` - The Google Developers Console project name. /// * `zone` - The name of the zone in which the update's target resides. /// * `rollingUpdate` - The name of the update. - pub fn cancel(&self, project: &str, zone: &str, rolling_update: &str) -> RollingUpdateCancelCall<'a, C, NC, A> { + pub fn cancel(&self, project: &str, zone: &str, rolling_update: &str) -> RollingUpdateCancelCall<'a, C, A> { RollingUpdateCancelCall { hub: self.hub, _project: project.to_string(), @@ -978,15 +974,15 @@ impl<'a, C, NC, A> RollingUpdateMethods<'a, C, NC, A> { /// let rb = hub.zone_operations(); /// # } /// ``` -pub struct ZoneOperationMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneOperationMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapoolupdater, + hub: &'a Replicapoolupdater, } -impl<'a, C, NC, A> MethodsBuilder for ZoneOperationMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ZoneOperationMethods<'a, C, A> {} -impl<'a, C, NC, A> ZoneOperationMethods<'a, C, NC, A> { +impl<'a, C, A> ZoneOperationMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -997,7 +993,7 @@ impl<'a, C, NC, A> ZoneOperationMethods<'a, C, NC, A> { /// * `project` - Name of the project scoping this request. /// * `zone` - Name of the zone scoping this request. /// * `operation` - Name of the operation resource to return. - pub fn get(&self, project: &str, zone: &str, operation: &str) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, zone: &str, operation: &str) -> ZoneOperationGetCall<'a, C, A> { ZoneOperationGetCall { hub: self.hub, _project: project.to_string(), @@ -1048,10 +1044,10 @@ impl<'a, C, NC, A> ZoneOperationMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct RollingUpdatePauseCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RollingUpdatePauseCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapoolupdater, + hub: &'a Replicapoolupdater, _project: String, _zone: String, _rolling_update: String, @@ -1060,9 +1056,9 @@ pub struct RollingUpdatePauseCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RollingUpdatePauseCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RollingUpdatePauseCall<'a, C, A> {} -impl<'a, C, NC, A> RollingUpdatePauseCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RollingUpdatePauseCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1196,7 +1192,7 @@ impl<'a, C, NC, A> RollingUpdatePauseCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The Google Developers Console project name. - pub fn project(mut self, new_value: &str) -> RollingUpdatePauseCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> RollingUpdatePauseCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1206,7 +1202,7 @@ impl<'a, C, NC, A> RollingUpdatePauseCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The name of the zone in which the update's target resides. - pub fn zone(mut self, new_value: &str) -> RollingUpdatePauseCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> RollingUpdatePauseCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -1216,7 +1212,7 @@ impl<'a, C, NC, A> RollingUpdatePauseCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The name of the update. - pub fn rolling_update(mut self, new_value: &str) -> RollingUpdatePauseCall<'a, C, NC, A> { + pub fn rolling_update(mut self, new_value: &str) -> RollingUpdatePauseCall<'a, C, A> { self._rolling_update = new_value.to_string(); self } @@ -1227,7 +1223,7 @@ impl<'a, C, NC, A> RollingUpdatePauseCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RollingUpdatePauseCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RollingUpdatePauseCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1248,7 +1244,7 @@ impl<'a, C, NC, A> RollingUpdatePauseCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RollingUpdatePauseCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RollingUpdatePauseCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1265,7 +1261,7 @@ impl<'a, C, NC, A> RollingUpdatePauseCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RollingUpdatePauseCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RollingUpdatePauseCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1303,10 +1299,10 @@ impl<'a, C, NC, A> RollingUpdatePauseCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct RollingUpdateRollbackCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RollingUpdateRollbackCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapoolupdater, + hub: &'a Replicapoolupdater, _project: String, _zone: String, _rolling_update: String, @@ -1315,9 +1311,9 @@ pub struct RollingUpdateRollbackCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RollingUpdateRollbackCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RollingUpdateRollbackCall<'a, C, A> {} -impl<'a, C, NC, A> RollingUpdateRollbackCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RollingUpdateRollbackCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1451,7 +1447,7 @@ impl<'a, C, NC, A> RollingUpdateRollbackCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The Google Developers Console project name. - pub fn project(mut self, new_value: &str) -> RollingUpdateRollbackCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> RollingUpdateRollbackCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1461,7 +1457,7 @@ impl<'a, C, NC, A> RollingUpdateRollbackCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The name of the zone in which the update's target resides. - pub fn zone(mut self, new_value: &str) -> RollingUpdateRollbackCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> RollingUpdateRollbackCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -1471,7 +1467,7 @@ impl<'a, C, NC, A> RollingUpdateRollbackCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The name of the update. - pub fn rolling_update(mut self, new_value: &str) -> RollingUpdateRollbackCall<'a, C, NC, A> { + pub fn rolling_update(mut self, new_value: &str) -> RollingUpdateRollbackCall<'a, C, A> { self._rolling_update = new_value.to_string(); self } @@ -1482,7 +1478,7 @@ impl<'a, C, NC, A> RollingUpdateRollbackCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RollingUpdateRollbackCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RollingUpdateRollbackCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1503,7 +1499,7 @@ impl<'a, C, NC, A> RollingUpdateRollbackCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RollingUpdateRollbackCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RollingUpdateRollbackCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1520,7 +1516,7 @@ impl<'a, C, NC, A> RollingUpdateRollbackCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RollingUpdateRollbackCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RollingUpdateRollbackCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1558,10 +1554,10 @@ impl<'a, C, NC, A> RollingUpdateRollbackCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct RollingUpdateGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RollingUpdateGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapoolupdater, + hub: &'a Replicapoolupdater, _project: String, _zone: String, _rolling_update: String, @@ -1570,9 +1566,9 @@ pub struct RollingUpdateGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RollingUpdateGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RollingUpdateGetCall<'a, C, A> {} -impl<'a, C, NC, A> RollingUpdateGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RollingUpdateGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1706,7 +1702,7 @@ impl<'a, C, NC, A> RollingUpdateGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The Google Developers Console project name. - pub fn project(mut self, new_value: &str) -> RollingUpdateGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> RollingUpdateGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1716,7 +1712,7 @@ impl<'a, C, NC, A> RollingUpdateGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The name of the zone in which the update's target resides. - pub fn zone(mut self, new_value: &str) -> RollingUpdateGetCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> RollingUpdateGetCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -1726,7 +1722,7 @@ impl<'a, C, NC, A> RollingUpdateGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The name of the update. - pub fn rolling_update(mut self, new_value: &str) -> RollingUpdateGetCall<'a, C, NC, A> { + pub fn rolling_update(mut self, new_value: &str) -> RollingUpdateGetCall<'a, C, A> { self._rolling_update = new_value.to_string(); self } @@ -1737,7 +1733,7 @@ impl<'a, C, NC, A> RollingUpdateGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RollingUpdateGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RollingUpdateGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1758,7 +1754,7 @@ impl<'a, C, NC, A> RollingUpdateGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RollingUpdateGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RollingUpdateGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1775,7 +1771,7 @@ impl<'a, C, NC, A> RollingUpdateGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RollingUpdateGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RollingUpdateGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1813,10 +1809,10 @@ impl<'a, C, NC, A> RollingUpdateGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct RollingUpdateResumeCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RollingUpdateResumeCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapoolupdater, + hub: &'a Replicapoolupdater, _project: String, _zone: String, _rolling_update: String, @@ -1825,9 +1821,9 @@ pub struct RollingUpdateResumeCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RollingUpdateResumeCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RollingUpdateResumeCall<'a, C, A> {} -impl<'a, C, NC, A> RollingUpdateResumeCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RollingUpdateResumeCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1961,7 +1957,7 @@ impl<'a, C, NC, A> RollingUpdateResumeCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The Google Developers Console project name. - pub fn project(mut self, new_value: &str) -> RollingUpdateResumeCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> RollingUpdateResumeCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1971,7 +1967,7 @@ impl<'a, C, NC, A> RollingUpdateResumeCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The name of the zone in which the update's target resides. - pub fn zone(mut self, new_value: &str) -> RollingUpdateResumeCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> RollingUpdateResumeCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -1981,7 +1977,7 @@ impl<'a, C, NC, A> RollingUpdateResumeCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The name of the update. - pub fn rolling_update(mut self, new_value: &str) -> RollingUpdateResumeCall<'a, C, NC, A> { + pub fn rolling_update(mut self, new_value: &str) -> RollingUpdateResumeCall<'a, C, A> { self._rolling_update = new_value.to_string(); self } @@ -1992,7 +1988,7 @@ impl<'a, C, NC, A> RollingUpdateResumeCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RollingUpdateResumeCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RollingUpdateResumeCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2013,7 +2009,7 @@ impl<'a, C, NC, A> RollingUpdateResumeCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RollingUpdateResumeCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RollingUpdateResumeCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2030,7 +2026,7 @@ impl<'a, C, NC, A> RollingUpdateResumeCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RollingUpdateResumeCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RollingUpdateResumeCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2072,10 +2068,10 @@ impl<'a, C, NC, A> RollingUpdateResumeCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct RollingUpdateListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RollingUpdateListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapoolupdater, + hub: &'a Replicapoolupdater, _project: String, _zone: String, _page_token: Option, @@ -2087,9 +2083,9 @@ pub struct RollingUpdateListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RollingUpdateListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RollingUpdateListCall<'a, C, A> {} -impl<'a, C, NC, A> RollingUpdateListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RollingUpdateListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2234,7 +2230,7 @@ impl<'a, C, NC, A> RollingUpdateListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The Google Developers Console project name. - pub fn project(mut self, new_value: &str) -> RollingUpdateListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> RollingUpdateListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2244,7 +2240,7 @@ impl<'a, C, NC, A> RollingUpdateListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The name of the zone in which the update's target resides. - pub fn zone(mut self, new_value: &str) -> RollingUpdateListCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> RollingUpdateListCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -2252,7 +2248,7 @@ impl<'a, C, NC, A> RollingUpdateListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> RollingUpdateListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> RollingUpdateListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2260,7 +2256,7 @@ impl<'a, C, NC, A> RollingUpdateListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> RollingUpdateListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> RollingUpdateListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2268,7 +2264,7 @@ impl<'a, C, NC, A> RollingUpdateListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The name of the instance group manager used for filtering. - pub fn instance_group_manager(mut self, new_value: &str) -> RollingUpdateListCall<'a, C, NC, A> { + pub fn instance_group_manager(mut self, new_value: &str) -> RollingUpdateListCall<'a, C, A> { self._instance_group_manager = Some(new_value.to_string()); self } @@ -2276,7 +2272,7 @@ impl<'a, C, NC, A> RollingUpdateListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> RollingUpdateListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> RollingUpdateListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -2287,7 +2283,7 @@ impl<'a, C, NC, A> RollingUpdateListCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RollingUpdateListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RollingUpdateListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2308,7 +2304,7 @@ impl<'a, C, NC, A> RollingUpdateListCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RollingUpdateListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RollingUpdateListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2325,7 +2321,7 @@ impl<'a, C, NC, A> RollingUpdateListCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RollingUpdateListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RollingUpdateListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2369,10 +2365,10 @@ impl<'a, C, NC, A> RollingUpdateListCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct RollingUpdateInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RollingUpdateInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapoolupdater, + hub: &'a Replicapoolupdater, _request: RollingUpdate, _project: String, _zone: String, @@ -2381,9 +2377,9 @@ pub struct RollingUpdateInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RollingUpdateInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RollingUpdateInsertCall<'a, C, A> {} -impl<'a, C, NC, A> RollingUpdateInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RollingUpdateInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2523,7 +2519,7 @@ impl<'a, C, NC, A> RollingUpdateInsertCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &RollingUpdate) -> RollingUpdateInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &RollingUpdate) -> RollingUpdateInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2533,7 +2529,7 @@ impl<'a, C, NC, A> RollingUpdateInsertCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The Google Developers Console project name. - pub fn project(mut self, new_value: &str) -> RollingUpdateInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> RollingUpdateInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2543,7 +2539,7 @@ impl<'a, C, NC, A> RollingUpdateInsertCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The name of the zone in which the update's target resides. - pub fn zone(mut self, new_value: &str) -> RollingUpdateInsertCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> RollingUpdateInsertCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -2554,7 +2550,7 @@ impl<'a, C, NC, A> RollingUpdateInsertCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RollingUpdateInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RollingUpdateInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2575,7 +2571,7 @@ impl<'a, C, NC, A> RollingUpdateInsertCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RollingUpdateInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RollingUpdateInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2592,7 +2588,7 @@ impl<'a, C, NC, A> RollingUpdateInsertCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RollingUpdateInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RollingUpdateInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2633,10 +2629,10 @@ impl<'a, C, NC, A> RollingUpdateInsertCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct RollingUpdateListInstanceUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RollingUpdateListInstanceUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapoolupdater, + hub: &'a Replicapoolupdater, _project: String, _zone: String, _rolling_update: String, @@ -2648,9 +2644,9 @@ pub struct RollingUpdateListInstanceUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RollingUpdateListInstanceUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RollingUpdateListInstanceUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> RollingUpdateListInstanceUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RollingUpdateListInstanceUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2793,7 +2789,7 @@ impl<'a, C, NC, A> RollingUpdateListInstanceUpdateCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// The Google Developers Console project name. - pub fn project(mut self, new_value: &str) -> RollingUpdateListInstanceUpdateCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> RollingUpdateListInstanceUpdateCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2803,7 +2799,7 @@ impl<'a, C, NC, A> RollingUpdateListInstanceUpdateCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// The name of the zone in which the update's target resides. - pub fn zone(mut self, new_value: &str) -> RollingUpdateListInstanceUpdateCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> RollingUpdateListInstanceUpdateCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -2813,7 +2809,7 @@ impl<'a, C, NC, A> RollingUpdateListInstanceUpdateCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// The name of the update. - pub fn rolling_update(mut self, new_value: &str) -> RollingUpdateListInstanceUpdateCall<'a, C, NC, A> { + pub fn rolling_update(mut self, new_value: &str) -> RollingUpdateListInstanceUpdateCall<'a, C, A> { self._rolling_update = new_value.to_string(); self } @@ -2821,7 +2817,7 @@ impl<'a, C, NC, A> RollingUpdateListInstanceUpdateCall<'a, C, NC, A> where NC: h /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> RollingUpdateListInstanceUpdateCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> RollingUpdateListInstanceUpdateCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2829,7 +2825,7 @@ impl<'a, C, NC, A> RollingUpdateListInstanceUpdateCall<'a, C, NC, A> where NC: h /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> RollingUpdateListInstanceUpdateCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> RollingUpdateListInstanceUpdateCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2837,7 +2833,7 @@ impl<'a, C, NC, A> RollingUpdateListInstanceUpdateCall<'a, C, NC, A> where NC: h /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> RollingUpdateListInstanceUpdateCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> RollingUpdateListInstanceUpdateCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -2848,7 +2844,7 @@ impl<'a, C, NC, A> RollingUpdateListInstanceUpdateCall<'a, C, NC, A> where NC: h /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RollingUpdateListInstanceUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RollingUpdateListInstanceUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2869,7 +2865,7 @@ impl<'a, C, NC, A> RollingUpdateListInstanceUpdateCall<'a, C, NC, A> where NC: h /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RollingUpdateListInstanceUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RollingUpdateListInstanceUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2886,7 +2882,7 @@ impl<'a, C, NC, A> RollingUpdateListInstanceUpdateCall<'a, C, NC, A> where NC: h /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RollingUpdateListInstanceUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RollingUpdateListInstanceUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2924,10 +2920,10 @@ impl<'a, C, NC, A> RollingUpdateListInstanceUpdateCall<'a, C, NC, A> where NC: h /// .doit(); /// # } /// ``` -pub struct RollingUpdateCancelCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct RollingUpdateCancelCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapoolupdater, + hub: &'a Replicapoolupdater, _project: String, _zone: String, _rolling_update: String, @@ -2936,9 +2932,9 @@ pub struct RollingUpdateCancelCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for RollingUpdateCancelCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for RollingUpdateCancelCall<'a, C, A> {} -impl<'a, C, NC, A> RollingUpdateCancelCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> RollingUpdateCancelCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3072,7 +3068,7 @@ impl<'a, C, NC, A> RollingUpdateCancelCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The Google Developers Console project name. - pub fn project(mut self, new_value: &str) -> RollingUpdateCancelCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> RollingUpdateCancelCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -3082,7 +3078,7 @@ impl<'a, C, NC, A> RollingUpdateCancelCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The name of the zone in which the update's target resides. - pub fn zone(mut self, new_value: &str) -> RollingUpdateCancelCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> RollingUpdateCancelCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -3092,7 +3088,7 @@ impl<'a, C, NC, A> RollingUpdateCancelCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The name of the update. - pub fn rolling_update(mut self, new_value: &str) -> RollingUpdateCancelCall<'a, C, NC, A> { + pub fn rolling_update(mut self, new_value: &str) -> RollingUpdateCancelCall<'a, C, A> { self._rolling_update = new_value.to_string(); self } @@ -3103,7 +3099,7 @@ impl<'a, C, NC, A> RollingUpdateCancelCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> RollingUpdateCancelCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> RollingUpdateCancelCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3124,7 +3120,7 @@ impl<'a, C, NC, A> RollingUpdateCancelCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> RollingUpdateCancelCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> RollingUpdateCancelCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3141,7 +3137,7 @@ impl<'a, C, NC, A> RollingUpdateCancelCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> RollingUpdateCancelCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> RollingUpdateCancelCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3179,10 +3175,10 @@ impl<'a, C, NC, A> RollingUpdateCancelCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct ZoneOperationGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneOperationGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Replicapoolupdater, + hub: &'a Replicapoolupdater, _project: String, _zone: String, _operation: String, @@ -3191,9 +3187,9 @@ pub struct ZoneOperationGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ZoneOperationGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ZoneOperationGetCall<'a, C, A> {} -impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ZoneOperationGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3327,7 +3323,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -3337,7 +3333,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Name of the zone scoping this request. - pub fn zone(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -3347,7 +3343,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Name of the operation resource to return. - pub fn operation(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn operation(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, A> { self._operation = new_value.to_string(); self } @@ -3358,7 +3354,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneOperationGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3379,7 +3375,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ZoneOperationGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ZoneOperationGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3396,7 +3392,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ZoneOperationGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ZoneOperationGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/reseller1_sandbox/Cargo.toml b/gen/reseller1_sandbox/Cargo.toml index 4827fba602b..b102de0d9a9 100644 --- a/gen/reseller1_sandbox/Cargo.toml +++ b/gen/reseller1_sandbox/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-reseller1_sandbox" -version = "0.1.4+20141112" +version = "0.1.5+20141112" authors = ["Sebastian Thiel "] description = "A complete library to interact with reseller (protocol v1sandbox)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/reseller1_sandbox" homepage = "https://developers.google.com/google-apps/reseller/" -documentation = "http://byron.github.io/google-apis-rs/google-reseller1_sandbox" +documentation = "http://byron.github.io/google-apis-rs/google_reseller1_sandbox" license = "MIT" keywords = ["reseller", "google", "protocol", "web", "api"] diff --git a/gen/reseller1_sandbox/README.md b/gen/reseller1_sandbox/README.md index 23b0e39bd9c..a93d3962c1d 100644 --- a/gen/reseller1_sandbox/README.md +++ b/gen/reseller1_sandbox/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-reseller1_sandbox` library allows access to all features of the *Google reseller* service. -This documentation was generated from *reseller* crate version *0.1.4+20141112*, where *20141112* is the exact revision of the *reseller:v1sandbox* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *reseller* crate version *0.1.5+20141112*, where *20141112* is the exact revision of the *reseller:v1sandbox* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *reseller* *v1_sandbox* API can be found at the [official documentation site](https://developers.google.com/google-apps/reseller/). diff --git a/gen/reseller1_sandbox/src/cmn.rs b/gen/reseller1_sandbox/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/reseller1_sandbox/src/cmn.rs +++ b/gen/reseller1_sandbox/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/reseller1_sandbox/src/lib.rs b/gen/reseller1_sandbox/src/lib.rs index 5add516d064..718879efb8b 100644 --- a/gen/reseller1_sandbox/src/lib.rs +++ b/gen/reseller1_sandbox/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *reseller* crate version *0.1.4+20141112*, where *20141112* is the exact revision of the *reseller:v1sandbox* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *reseller* crate version *0.1.5+20141112*, where *20141112* is the exact revision of the *reseller:v1sandbox* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *reseller* *v1_sandbox* API can be found at the //! [official documentation site](https://developers.google.com/google-apps/reseller/). @@ -204,7 +204,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -304,37 +303,34 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Reseller { +pub struct Reseller { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Reseller {} +impl<'a, C, A> Hub for Reseller {} -impl<'a, C, NC, A> Reseller - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Reseller + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Reseller { + pub fn new(client: C, authenticator: A) -> Reseller { Reseller { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn customers(&'a self) -> CustomerMethods<'a, C, NC, A> { + pub fn customers(&'a self) -> CustomerMethods<'a, C, A> { CustomerMethods { hub: &self } } - pub fn subscriptions(&'a self) -> SubscriptionMethods<'a, C, NC, A> { + pub fn subscriptions(&'a self) -> SubscriptionMethods<'a, C, A> { SubscriptionMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -697,15 +693,15 @@ impl ResponseResult for Subscription {} /// let rb = hub.customers(); /// # } /// ``` -pub struct CustomerMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CustomerMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reseller, + hub: &'a Reseller, } -impl<'a, C, NC, A> MethodsBuilder for CustomerMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CustomerMethods<'a, C, A> {} -impl<'a, C, NC, A> CustomerMethods<'a, C, NC, A> { +impl<'a, C, A> CustomerMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -715,7 +711,7 @@ impl<'a, C, NC, A> CustomerMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `customerId` - Id of the Customer - pub fn update(&self, request: &Customer, customer_id: &str) -> CustomerUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Customer, customer_id: &str) -> CustomerUpdateCall<'a, C, A> { CustomerUpdateCall { hub: self.hub, _request: request.clone(), @@ -733,7 +729,7 @@ impl<'a, C, NC, A> CustomerMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &Customer) -> CustomerInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Customer) -> CustomerInsertCall<'a, C, A> { CustomerInsertCall { hub: self.hub, _request: request.clone(), @@ -752,7 +748,7 @@ impl<'a, C, NC, A> CustomerMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `customerId` - Id of the Customer - pub fn patch(&self, request: &Customer, customer_id: &str) -> CustomerPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Customer, customer_id: &str) -> CustomerPatchCall<'a, C, A> { CustomerPatchCall { hub: self.hub, _request: request.clone(), @@ -770,7 +766,7 @@ impl<'a, C, NC, A> CustomerMethods<'a, C, NC, A> { /// # Arguments /// /// * `customerId` - Id of the Customer - pub fn get(&self, customer_id: &str) -> CustomerGetCall<'a, C, NC, A> { + pub fn get(&self, customer_id: &str) -> CustomerGetCall<'a, C, A> { CustomerGetCall { hub: self.hub, _customer_id: customer_id.to_string(), @@ -811,15 +807,15 @@ impl<'a, C, NC, A> CustomerMethods<'a, C, NC, A> { /// let rb = hub.subscriptions(); /// # } /// ``` -pub struct SubscriptionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubscriptionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reseller, + hub: &'a Reseller, } -impl<'a, C, NC, A> MethodsBuilder for SubscriptionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for SubscriptionMethods<'a, C, A> {} -impl<'a, C, NC, A> SubscriptionMethods<'a, C, NC, A> { +impl<'a, C, A> SubscriptionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -829,7 +825,7 @@ impl<'a, C, NC, A> SubscriptionMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `customerId` - Id of the Customer - pub fn insert(&self, request: &Subscription, customer_id: &str) -> SubscriptionInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Subscription, customer_id: &str) -> SubscriptionInsertCall<'a, C, A> { SubscriptionInsertCall { hub: self.hub, _request: request.clone(), @@ -850,7 +846,7 @@ impl<'a, C, NC, A> SubscriptionMethods<'a, C, NC, A> { /// * `customerId` - Id of the Customer /// * `subscriptionId` - Id of the subscription, which is unique for a customer /// * `deletionType` - Whether the subscription is to be fully cancelled or downgraded - pub fn delete(&self, customer_id: &str, subscription_id: &str, deletion_type: &str) -> SubscriptionDeleteCall<'a, C, NC, A> { + pub fn delete(&self, customer_id: &str, subscription_id: &str, deletion_type: &str) -> SubscriptionDeleteCall<'a, C, A> { SubscriptionDeleteCall { hub: self.hub, _customer_id: customer_id.to_string(), @@ -870,7 +866,7 @@ impl<'a, C, NC, A> SubscriptionMethods<'a, C, NC, A> { /// /// * `customerId` - Id of the Customer /// * `subscriptionId` - Id of the subscription, which is unique for a customer - pub fn get(&self, customer_id: &str, subscription_id: &str) -> SubscriptionGetCall<'a, C, NC, A> { + pub fn get(&self, customer_id: &str, subscription_id: &str) -> SubscriptionGetCall<'a, C, A> { SubscriptionGetCall { hub: self.hub, _customer_id: customer_id.to_string(), @@ -884,7 +880,7 @@ impl<'a, C, NC, A> SubscriptionMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Lists subscriptions of a reseller, optionally filtered by a customer name prefix. - pub fn list(&self) -> SubscriptionListCall<'a, C, NC, A> { + pub fn list(&self) -> SubscriptionListCall<'a, C, A> { SubscriptionListCall { hub: self.hub, _page_token: Default::default(), @@ -907,7 +903,7 @@ impl<'a, C, NC, A> SubscriptionMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `customerId` - Id of the Customer /// * `subscriptionId` - Id of the subscription, which is unique for a customer - pub fn change_renewal_settings(&self, request: &RenewalSettings, customer_id: &str, subscription_id: &str) -> SubscriptionChangeRenewalSettingCall<'a, C, NC, A> { + pub fn change_renewal_settings(&self, request: &RenewalSettings, customer_id: &str, subscription_id: &str) -> SubscriptionChangeRenewalSettingCall<'a, C, A> { SubscriptionChangeRenewalSettingCall { hub: self.hub, _request: request.clone(), @@ -927,7 +923,7 @@ impl<'a, C, NC, A> SubscriptionMethods<'a, C, NC, A> { /// /// * `customerId` - Id of the Customer /// * `subscriptionId` - Id of the subscription, which is unique for a customer - pub fn start_paid_service(&self, customer_id: &str, subscription_id: &str) -> SubscriptionStartPaidServiceCall<'a, C, NC, A> { + pub fn start_paid_service(&self, customer_id: &str, subscription_id: &str) -> SubscriptionStartPaidServiceCall<'a, C, A> { SubscriptionStartPaidServiceCall { hub: self.hub, _customer_id: customer_id.to_string(), @@ -947,7 +943,7 @@ impl<'a, C, NC, A> SubscriptionMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `customerId` - Id of the Customer /// * `subscriptionId` - Id of the subscription, which is unique for a customer - pub fn change_seats(&self, request: &Seats, customer_id: &str, subscription_id: &str) -> SubscriptionChangeSeatCall<'a, C, NC, A> { + pub fn change_seats(&self, request: &Seats, customer_id: &str, subscription_id: &str) -> SubscriptionChangeSeatCall<'a, C, A> { SubscriptionChangeSeatCall { hub: self.hub, _request: request.clone(), @@ -967,7 +963,7 @@ impl<'a, C, NC, A> SubscriptionMethods<'a, C, NC, A> { /// /// * `customerId` - Id of the Customer /// * `subscriptionId` - Id of the subscription, which is unique for a customer - pub fn suspend(&self, customer_id: &str, subscription_id: &str) -> SubscriptionSuspendCall<'a, C, NC, A> { + pub fn suspend(&self, customer_id: &str, subscription_id: &str) -> SubscriptionSuspendCall<'a, C, A> { SubscriptionSuspendCall { hub: self.hub, _customer_id: customer_id.to_string(), @@ -986,7 +982,7 @@ impl<'a, C, NC, A> SubscriptionMethods<'a, C, NC, A> { /// /// * `customerId` - Id of the Customer /// * `subscriptionId` - Id of the subscription, which is unique for a customer - pub fn activate(&self, customer_id: &str, subscription_id: &str) -> SubscriptionActivateCall<'a, C, NC, A> { + pub fn activate(&self, customer_id: &str, subscription_id: &str) -> SubscriptionActivateCall<'a, C, A> { SubscriptionActivateCall { hub: self.hub, _customer_id: customer_id.to_string(), @@ -1006,7 +1002,7 @@ impl<'a, C, NC, A> SubscriptionMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `customerId` - Id of the Customer /// * `subscriptionId` - Id of the subscription, which is unique for a customer - pub fn change_plan(&self, request: &ChangePlanRequest, customer_id: &str, subscription_id: &str) -> SubscriptionChangePlanCall<'a, C, NC, A> { + pub fn change_plan(&self, request: &ChangePlanRequest, customer_id: &str, subscription_id: &str) -> SubscriptionChangePlanCall<'a, C, A> { SubscriptionChangePlanCall { hub: self.hub, _request: request.clone(), @@ -1063,10 +1059,10 @@ impl<'a, C, NC, A> SubscriptionMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct CustomerUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CustomerUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reseller, + hub: &'a Reseller, _request: Customer, _customer_id: String, _delegate: Option<&'a mut Delegate>, @@ -1074,9 +1070,9 @@ pub struct CustomerUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CustomerUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CustomerUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> CustomerUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CustomerUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1215,7 +1211,7 @@ impl<'a, C, NC, A> CustomerUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Customer) -> CustomerUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Customer) -> CustomerUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1225,7 +1221,7 @@ impl<'a, C, NC, A> CustomerUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Id of the Customer - pub fn customer_id(mut self, new_value: &str) -> CustomerUpdateCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> CustomerUpdateCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -1236,7 +1232,7 @@ impl<'a, C, NC, A> CustomerUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomerUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomerUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1257,7 +1253,7 @@ impl<'a, C, NC, A> CustomerUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CustomerUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CustomerUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1274,7 +1270,7 @@ impl<'a, C, NC, A> CustomerUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CustomerUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CustomerUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1319,10 +1315,10 @@ impl<'a, C, NC, A> CustomerUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct CustomerInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CustomerInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reseller, + hub: &'a Reseller, _request: Customer, _customer_auth_token: Option, _delegate: Option<&'a mut Delegate>, @@ -1330,9 +1326,9 @@ pub struct CustomerInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CustomerInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CustomerInsertCall<'a, C, A> {} -impl<'a, C, NC, A> CustomerInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CustomerInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1449,7 +1445,7 @@ impl<'a, C, NC, A> CustomerInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Customer) -> CustomerInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Customer) -> CustomerInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1457,7 +1453,7 @@ impl<'a, C, NC, A> CustomerInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// An auth token needed for inserting a customer for which domain already exists. Can be generated at https://www.google.com/a/cpanel//TransferToken. Optional. - pub fn customer_auth_token(mut self, new_value: &str) -> CustomerInsertCall<'a, C, NC, A> { + pub fn customer_auth_token(mut self, new_value: &str) -> CustomerInsertCall<'a, C, A> { self._customer_auth_token = Some(new_value.to_string()); self } @@ -1468,7 +1464,7 @@ impl<'a, C, NC, A> CustomerInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomerInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomerInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1489,7 +1485,7 @@ impl<'a, C, NC, A> CustomerInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CustomerInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CustomerInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1506,7 +1502,7 @@ impl<'a, C, NC, A> CustomerInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CustomerInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CustomerInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1550,10 +1546,10 @@ impl<'a, C, NC, A> CustomerInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct CustomerPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CustomerPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reseller, + hub: &'a Reseller, _request: Customer, _customer_id: String, _delegate: Option<&'a mut Delegate>, @@ -1561,9 +1557,9 @@ pub struct CustomerPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CustomerPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CustomerPatchCall<'a, C, A> {} -impl<'a, C, NC, A> CustomerPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CustomerPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1702,7 +1698,7 @@ impl<'a, C, NC, A> CustomerPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Customer) -> CustomerPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Customer) -> CustomerPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1712,7 +1708,7 @@ impl<'a, C, NC, A> CustomerPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Id of the Customer - pub fn customer_id(mut self, new_value: &str) -> CustomerPatchCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> CustomerPatchCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -1723,7 +1719,7 @@ impl<'a, C, NC, A> CustomerPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomerPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomerPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1744,7 +1740,7 @@ impl<'a, C, NC, A> CustomerPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CustomerPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CustomerPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1761,7 +1757,7 @@ impl<'a, C, NC, A> CustomerPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CustomerPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CustomerPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1799,19 +1795,19 @@ impl<'a, C, NC, A> CustomerPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct CustomerGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CustomerGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reseller, + hub: &'a Reseller, _customer_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CustomerGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CustomerGetCall<'a, C, A> {} -impl<'a, C, NC, A> CustomerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CustomerGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1943,7 +1939,7 @@ impl<'a, C, NC, A> CustomerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Id of the Customer - pub fn customer_id(mut self, new_value: &str) -> CustomerGetCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> CustomerGetCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -1954,7 +1950,7 @@ impl<'a, C, NC, A> CustomerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomerGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CustomerGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1975,7 +1971,7 @@ impl<'a, C, NC, A> CustomerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CustomerGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CustomerGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1992,7 +1988,7 @@ impl<'a, C, NC, A> CustomerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CustomerGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CustomerGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2037,10 +2033,10 @@ impl<'a, C, NC, A> CustomerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct SubscriptionInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubscriptionInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reseller, + hub: &'a Reseller, _request: Subscription, _customer_id: String, _customer_auth_token: Option, @@ -2049,9 +2045,9 @@ pub struct SubscriptionInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SubscriptionInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SubscriptionInsertCall<'a, C, A> {} -impl<'a, C, NC, A> SubscriptionInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SubscriptionInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2193,7 +2189,7 @@ impl<'a, C, NC, A> SubscriptionInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Subscription) -> SubscriptionInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Subscription) -> SubscriptionInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2203,7 +2199,7 @@ impl<'a, C, NC, A> SubscriptionInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Id of the Customer - pub fn customer_id(mut self, new_value: &str) -> SubscriptionInsertCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> SubscriptionInsertCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -2211,7 +2207,7 @@ impl<'a, C, NC, A> SubscriptionInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// An auth token needed for transferring a subscription. Can be generated at https://www.google.com/a/cpanel/customer-domain/TransferToken. Optional. - pub fn customer_auth_token(mut self, new_value: &str) -> SubscriptionInsertCall<'a, C, NC, A> { + pub fn customer_auth_token(mut self, new_value: &str) -> SubscriptionInsertCall<'a, C, A> { self._customer_auth_token = Some(new_value.to_string()); self } @@ -2222,7 +2218,7 @@ impl<'a, C, NC, A> SubscriptionInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2243,7 +2239,7 @@ impl<'a, C, NC, A> SubscriptionInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SubscriptionInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SubscriptionInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2260,7 +2256,7 @@ impl<'a, C, NC, A> SubscriptionInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SubscriptionInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SubscriptionInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2298,10 +2294,10 @@ impl<'a, C, NC, A> SubscriptionInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct SubscriptionDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubscriptionDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reseller, + hub: &'a Reseller, _customer_id: String, _subscription_id: String, _deletion_type: String, @@ -2310,9 +2306,9 @@ pub struct SubscriptionDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SubscriptionDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SubscriptionDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> SubscriptionDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SubscriptionDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2435,7 +2431,7 @@ impl<'a, C, NC, A> SubscriptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Id of the Customer - pub fn customer_id(mut self, new_value: &str) -> SubscriptionDeleteCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> SubscriptionDeleteCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -2445,7 +2441,7 @@ impl<'a, C, NC, A> SubscriptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Id of the subscription, which is unique for a customer - pub fn subscription_id(mut self, new_value: &str) -> SubscriptionDeleteCall<'a, C, NC, A> { + pub fn subscription_id(mut self, new_value: &str) -> SubscriptionDeleteCall<'a, C, A> { self._subscription_id = new_value.to_string(); self } @@ -2455,7 +2451,7 @@ impl<'a, C, NC, A> SubscriptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// Whether the subscription is to be fully cancelled or downgraded - pub fn deletion_type(mut self, new_value: &str) -> SubscriptionDeleteCall<'a, C, NC, A> { + pub fn deletion_type(mut self, new_value: &str) -> SubscriptionDeleteCall<'a, C, A> { self._deletion_type = new_value.to_string(); self } @@ -2466,7 +2462,7 @@ impl<'a, C, NC, A> SubscriptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2487,7 +2483,7 @@ impl<'a, C, NC, A> SubscriptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SubscriptionDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SubscriptionDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2504,7 +2500,7 @@ impl<'a, C, NC, A> SubscriptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SubscriptionDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SubscriptionDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2542,10 +2538,10 @@ impl<'a, C, NC, A> SubscriptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct SubscriptionGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubscriptionGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reseller, + hub: &'a Reseller, _customer_id: String, _subscription_id: String, _delegate: Option<&'a mut Delegate>, @@ -2553,9 +2549,9 @@ pub struct SubscriptionGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SubscriptionGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SubscriptionGetCall<'a, C, A> {} -impl<'a, C, NC, A> SubscriptionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SubscriptionGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2688,7 +2684,7 @@ impl<'a, C, NC, A> SubscriptionGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Id of the Customer - pub fn customer_id(mut self, new_value: &str) -> SubscriptionGetCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> SubscriptionGetCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -2698,7 +2694,7 @@ impl<'a, C, NC, A> SubscriptionGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Id of the subscription, which is unique for a customer - pub fn subscription_id(mut self, new_value: &str) -> SubscriptionGetCall<'a, C, NC, A> { + pub fn subscription_id(mut self, new_value: &str) -> SubscriptionGetCall<'a, C, A> { self._subscription_id = new_value.to_string(); self } @@ -2709,7 +2705,7 @@ impl<'a, C, NC, A> SubscriptionGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2730,7 +2726,7 @@ impl<'a, C, NC, A> SubscriptionGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SubscriptionGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SubscriptionGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2747,7 +2743,7 @@ impl<'a, C, NC, A> SubscriptionGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SubscriptionGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SubscriptionGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2790,10 +2786,10 @@ impl<'a, C, NC, A> SubscriptionGetCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct SubscriptionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubscriptionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reseller, + hub: &'a Reseller, _page_token: Option, _max_results: Option, _customer_name_prefix: Option, @@ -2804,9 +2800,9 @@ pub struct SubscriptionListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SubscriptionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SubscriptionListCall<'a, C, A> {} -impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SubscriptionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2926,7 +2922,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Token to specify next page in the list - pub fn page_token(mut self, new_value: &str) -> SubscriptionListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> SubscriptionListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2934,7 +2930,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Maximum number of results to return - pub fn max_results(mut self, new_value: u32) -> SubscriptionListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> SubscriptionListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2942,7 +2938,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Prefix of the customer's domain name by which the subscriptions should be filtered. Optional - pub fn customer_name_prefix(mut self, new_value: &str) -> SubscriptionListCall<'a, C, NC, A> { + pub fn customer_name_prefix(mut self, new_value: &str) -> SubscriptionListCall<'a, C, A> { self._customer_name_prefix = Some(new_value.to_string()); self } @@ -2950,7 +2946,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Id of the Customer - pub fn customer_id(mut self, new_value: &str) -> SubscriptionListCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> SubscriptionListCall<'a, C, A> { self._customer_id = Some(new_value.to_string()); self } @@ -2958,7 +2954,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// An auth token needed if the customer is not a resold customer of this reseller. Can be generated at https://www.google.com/a/cpanel/customer-domain/TransferToken.Optional. - pub fn customer_auth_token(mut self, new_value: &str) -> SubscriptionListCall<'a, C, NC, A> { + pub fn customer_auth_token(mut self, new_value: &str) -> SubscriptionListCall<'a, C, A> { self._customer_auth_token = Some(new_value.to_string()); self } @@ -2969,7 +2965,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2990,7 +2986,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SubscriptionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SubscriptionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3007,7 +3003,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SubscriptionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SubscriptionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3051,10 +3047,10 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct SubscriptionChangeRenewalSettingCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubscriptionChangeRenewalSettingCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reseller, + hub: &'a Reseller, _request: RenewalSettings, _customer_id: String, _subscription_id: String, @@ -3063,9 +3059,9 @@ pub struct SubscriptionChangeRenewalSettingCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SubscriptionChangeRenewalSettingCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SubscriptionChangeRenewalSettingCall<'a, C, A> {} -impl<'a, C, NC, A> SubscriptionChangeRenewalSettingCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SubscriptionChangeRenewalSettingCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3205,7 +3201,7 @@ impl<'a, C, NC, A> SubscriptionChangeRenewalSettingCall<'a, C, NC, A> where NC: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &RenewalSettings) -> SubscriptionChangeRenewalSettingCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &RenewalSettings) -> SubscriptionChangeRenewalSettingCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3215,7 +3211,7 @@ impl<'a, C, NC, A> SubscriptionChangeRenewalSettingCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Id of the Customer - pub fn customer_id(mut self, new_value: &str) -> SubscriptionChangeRenewalSettingCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> SubscriptionChangeRenewalSettingCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -3225,7 +3221,7 @@ impl<'a, C, NC, A> SubscriptionChangeRenewalSettingCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Id of the subscription, which is unique for a customer - pub fn subscription_id(mut self, new_value: &str) -> SubscriptionChangeRenewalSettingCall<'a, C, NC, A> { + pub fn subscription_id(mut self, new_value: &str) -> SubscriptionChangeRenewalSettingCall<'a, C, A> { self._subscription_id = new_value.to_string(); self } @@ -3236,7 +3232,7 @@ impl<'a, C, NC, A> SubscriptionChangeRenewalSettingCall<'a, C, NC, A> where NC: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionChangeRenewalSettingCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionChangeRenewalSettingCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3257,7 +3253,7 @@ impl<'a, C, NC, A> SubscriptionChangeRenewalSettingCall<'a, C, NC, A> where NC: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SubscriptionChangeRenewalSettingCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SubscriptionChangeRenewalSettingCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3274,7 +3270,7 @@ impl<'a, C, NC, A> SubscriptionChangeRenewalSettingCall<'a, C, NC, A> where NC: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SubscriptionChangeRenewalSettingCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SubscriptionChangeRenewalSettingCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3312,10 +3308,10 @@ impl<'a, C, NC, A> SubscriptionChangeRenewalSettingCall<'a, C, NC, A> where NC: /// .doit(); /// # } /// ``` -pub struct SubscriptionStartPaidServiceCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubscriptionStartPaidServiceCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reseller, + hub: &'a Reseller, _customer_id: String, _subscription_id: String, _delegate: Option<&'a mut Delegate>, @@ -3323,9 +3319,9 @@ pub struct SubscriptionStartPaidServiceCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SubscriptionStartPaidServiceCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SubscriptionStartPaidServiceCall<'a, C, A> {} -impl<'a, C, NC, A> SubscriptionStartPaidServiceCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SubscriptionStartPaidServiceCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3458,7 +3454,7 @@ impl<'a, C, NC, A> SubscriptionStartPaidServiceCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// Id of the Customer - pub fn customer_id(mut self, new_value: &str) -> SubscriptionStartPaidServiceCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> SubscriptionStartPaidServiceCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -3468,7 +3464,7 @@ impl<'a, C, NC, A> SubscriptionStartPaidServiceCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// Id of the subscription, which is unique for a customer - pub fn subscription_id(mut self, new_value: &str) -> SubscriptionStartPaidServiceCall<'a, C, NC, A> { + pub fn subscription_id(mut self, new_value: &str) -> SubscriptionStartPaidServiceCall<'a, C, A> { self._subscription_id = new_value.to_string(); self } @@ -3479,7 +3475,7 @@ impl<'a, C, NC, A> SubscriptionStartPaidServiceCall<'a, C, NC, A> where NC: hype /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionStartPaidServiceCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionStartPaidServiceCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3500,7 +3496,7 @@ impl<'a, C, NC, A> SubscriptionStartPaidServiceCall<'a, C, NC, A> where NC: hype /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SubscriptionStartPaidServiceCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SubscriptionStartPaidServiceCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3517,7 +3513,7 @@ impl<'a, C, NC, A> SubscriptionStartPaidServiceCall<'a, C, NC, A> where NC: hype /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SubscriptionStartPaidServiceCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SubscriptionStartPaidServiceCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3561,10 +3557,10 @@ impl<'a, C, NC, A> SubscriptionStartPaidServiceCall<'a, C, NC, A> where NC: hype /// .doit(); /// # } /// ``` -pub struct SubscriptionChangeSeatCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubscriptionChangeSeatCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reseller, + hub: &'a Reseller, _request: Seats, _customer_id: String, _subscription_id: String, @@ -3573,9 +3569,9 @@ pub struct SubscriptionChangeSeatCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SubscriptionChangeSeatCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SubscriptionChangeSeatCall<'a, C, A> {} -impl<'a, C, NC, A> SubscriptionChangeSeatCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SubscriptionChangeSeatCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3715,7 +3711,7 @@ impl<'a, C, NC, A> SubscriptionChangeSeatCall<'a, C, NC, A> where NC: hyper::net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Seats) -> SubscriptionChangeSeatCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Seats) -> SubscriptionChangeSeatCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3725,7 +3721,7 @@ impl<'a, C, NC, A> SubscriptionChangeSeatCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Id of the Customer - pub fn customer_id(mut self, new_value: &str) -> SubscriptionChangeSeatCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> SubscriptionChangeSeatCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -3735,7 +3731,7 @@ impl<'a, C, NC, A> SubscriptionChangeSeatCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Id of the subscription, which is unique for a customer - pub fn subscription_id(mut self, new_value: &str) -> SubscriptionChangeSeatCall<'a, C, NC, A> { + pub fn subscription_id(mut self, new_value: &str) -> SubscriptionChangeSeatCall<'a, C, A> { self._subscription_id = new_value.to_string(); self } @@ -3746,7 +3742,7 @@ impl<'a, C, NC, A> SubscriptionChangeSeatCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionChangeSeatCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionChangeSeatCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3767,7 +3763,7 @@ impl<'a, C, NC, A> SubscriptionChangeSeatCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SubscriptionChangeSeatCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SubscriptionChangeSeatCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3784,7 +3780,7 @@ impl<'a, C, NC, A> SubscriptionChangeSeatCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SubscriptionChangeSeatCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SubscriptionChangeSeatCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3822,10 +3818,10 @@ impl<'a, C, NC, A> SubscriptionChangeSeatCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct SubscriptionSuspendCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubscriptionSuspendCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reseller, + hub: &'a Reseller, _customer_id: String, _subscription_id: String, _delegate: Option<&'a mut Delegate>, @@ -3833,9 +3829,9 @@ pub struct SubscriptionSuspendCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SubscriptionSuspendCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SubscriptionSuspendCall<'a, C, A> {} -impl<'a, C, NC, A> SubscriptionSuspendCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SubscriptionSuspendCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3968,7 +3964,7 @@ impl<'a, C, NC, A> SubscriptionSuspendCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Id of the Customer - pub fn customer_id(mut self, new_value: &str) -> SubscriptionSuspendCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> SubscriptionSuspendCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -3978,7 +3974,7 @@ impl<'a, C, NC, A> SubscriptionSuspendCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Id of the subscription, which is unique for a customer - pub fn subscription_id(mut self, new_value: &str) -> SubscriptionSuspendCall<'a, C, NC, A> { + pub fn subscription_id(mut self, new_value: &str) -> SubscriptionSuspendCall<'a, C, A> { self._subscription_id = new_value.to_string(); self } @@ -3989,7 +3985,7 @@ impl<'a, C, NC, A> SubscriptionSuspendCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionSuspendCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionSuspendCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4010,7 +4006,7 @@ impl<'a, C, NC, A> SubscriptionSuspendCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SubscriptionSuspendCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SubscriptionSuspendCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4027,7 +4023,7 @@ impl<'a, C, NC, A> SubscriptionSuspendCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SubscriptionSuspendCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SubscriptionSuspendCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4065,10 +4061,10 @@ impl<'a, C, NC, A> SubscriptionSuspendCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct SubscriptionActivateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubscriptionActivateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reseller, + hub: &'a Reseller, _customer_id: String, _subscription_id: String, _delegate: Option<&'a mut Delegate>, @@ -4076,9 +4072,9 @@ pub struct SubscriptionActivateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SubscriptionActivateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SubscriptionActivateCall<'a, C, A> {} -impl<'a, C, NC, A> SubscriptionActivateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SubscriptionActivateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4211,7 +4207,7 @@ impl<'a, C, NC, A> SubscriptionActivateCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Id of the Customer - pub fn customer_id(mut self, new_value: &str) -> SubscriptionActivateCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> SubscriptionActivateCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -4221,7 +4217,7 @@ impl<'a, C, NC, A> SubscriptionActivateCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Id of the subscription, which is unique for a customer - pub fn subscription_id(mut self, new_value: &str) -> SubscriptionActivateCall<'a, C, NC, A> { + pub fn subscription_id(mut self, new_value: &str) -> SubscriptionActivateCall<'a, C, A> { self._subscription_id = new_value.to_string(); self } @@ -4232,7 +4228,7 @@ impl<'a, C, NC, A> SubscriptionActivateCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionActivateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionActivateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4253,7 +4249,7 @@ impl<'a, C, NC, A> SubscriptionActivateCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SubscriptionActivateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SubscriptionActivateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4270,7 +4266,7 @@ impl<'a, C, NC, A> SubscriptionActivateCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SubscriptionActivateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SubscriptionActivateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4314,10 +4310,10 @@ impl<'a, C, NC, A> SubscriptionActivateCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct SubscriptionChangePlanCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubscriptionChangePlanCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Reseller, + hub: &'a Reseller, _request: ChangePlanRequest, _customer_id: String, _subscription_id: String, @@ -4326,9 +4322,9 @@ pub struct SubscriptionChangePlanCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SubscriptionChangePlanCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SubscriptionChangePlanCall<'a, C, A> {} -impl<'a, C, NC, A> SubscriptionChangePlanCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SubscriptionChangePlanCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4468,7 +4464,7 @@ impl<'a, C, NC, A> SubscriptionChangePlanCall<'a, C, NC, A> where NC: hyper::net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ChangePlanRequest) -> SubscriptionChangePlanCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ChangePlanRequest) -> SubscriptionChangePlanCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4478,7 +4474,7 @@ impl<'a, C, NC, A> SubscriptionChangePlanCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Id of the Customer - pub fn customer_id(mut self, new_value: &str) -> SubscriptionChangePlanCall<'a, C, NC, A> { + pub fn customer_id(mut self, new_value: &str) -> SubscriptionChangePlanCall<'a, C, A> { self._customer_id = new_value.to_string(); self } @@ -4488,7 +4484,7 @@ impl<'a, C, NC, A> SubscriptionChangePlanCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Id of the subscription, which is unique for a customer - pub fn subscription_id(mut self, new_value: &str) -> SubscriptionChangePlanCall<'a, C, NC, A> { + pub fn subscription_id(mut self, new_value: &str) -> SubscriptionChangePlanCall<'a, C, A> { self._subscription_id = new_value.to_string(); self } @@ -4499,7 +4495,7 @@ impl<'a, C, NC, A> SubscriptionChangePlanCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionChangePlanCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionChangePlanCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4520,7 +4516,7 @@ impl<'a, C, NC, A> SubscriptionChangePlanCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SubscriptionChangePlanCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SubscriptionChangePlanCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4537,7 +4533,7 @@ impl<'a, C, NC, A> SubscriptionChangePlanCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SubscriptionChangePlanCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SubscriptionChangePlanCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/resourceviews1_beta2/Cargo.toml b/gen/resourceviews1_beta2/Cargo.toml index 12fa8f0e5c4..51f5e7eeab5 100644 --- a/gen/resourceviews1_beta2/Cargo.toml +++ b/gen/resourceviews1_beta2/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-resourceviews1_beta2" -version = "0.1.4+20150302" +version = "0.1.5+20150302" authors = ["Sebastian Thiel "] description = "A complete library to interact with resourceviews (protocol v1beta2)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/resourceviews1_beta2" homepage = "https://developers.google.com/compute/" -documentation = "http://byron.github.io/google-apis-rs/google-resourceviews1_beta2" +documentation = "http://byron.github.io/google-apis-rs/google_resourceviews1_beta2" license = "MIT" keywords = ["resourceviews", "google", "protocol", "web", "api"] diff --git a/gen/resourceviews1_beta2/README.md b/gen/resourceviews1_beta2/README.md index 4be1bb77db5..f95a387f5fe 100644 --- a/gen/resourceviews1_beta2/README.md +++ b/gen/resourceviews1_beta2/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-resourceviews1_beta2` library allows access to all features of the *Google resourceviews* service. -This documentation was generated from *resourceviews* crate version *0.1.4+20150302*, where *20150302* is the exact revision of the *resourceviews:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *resourceviews* crate version *0.1.5+20150302*, where *20150302* is the exact revision of the *resourceviews:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *resourceviews* *v1_beta2* API can be found at the [official documentation site](https://developers.google.com/compute/). diff --git a/gen/resourceviews1_beta2/src/cmn.rs b/gen/resourceviews1_beta2/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/resourceviews1_beta2/src/cmn.rs +++ b/gen/resourceviews1_beta2/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/resourceviews1_beta2/src/lib.rs b/gen/resourceviews1_beta2/src/lib.rs index 70625d259dd..eb1ef0aa3d9 100644 --- a/gen/resourceviews1_beta2/src/lib.rs +++ b/gen/resourceviews1_beta2/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *resourceviews* crate version *0.1.4+20150302*, where *20150302* is the exact revision of the *resourceviews:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *resourceviews* crate version *0.1.5+20150302*, where *20150302* is the exact revision of the *resourceviews:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *resourceviews* *v1_beta2* API can be found at the //! [official documentation site](https://developers.google.com/compute/). @@ -201,7 +201,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -314,37 +313,34 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Resourceviews { +pub struct Resourceviews { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Resourceviews {} +impl<'a, C, A> Hub for Resourceviews {} -impl<'a, C, NC, A> Resourceviews - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Resourceviews + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Resourceviews { + pub fn new(client: C, authenticator: A) -> Resourceviews { Resourceviews { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn zone_operations(&'a self) -> ZoneOperationMethods<'a, C, NC, A> { + pub fn zone_operations(&'a self) -> ZoneOperationMethods<'a, C, A> { ZoneOperationMethods { hub: &self } } - pub fn zone_views(&'a self) -> ZoneViewMethods<'a, C, NC, A> { + pub fn zone_views(&'a self) -> ZoneViewMethods<'a, C, A> { ZoneViewMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -779,15 +775,15 @@ impl Part for OperationWarningsData {} /// let rb = hub.zone_views(); /// # } /// ``` -pub struct ZoneViewMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneViewMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Resourceviews, + hub: &'a Resourceviews, } -impl<'a, C, NC, A> MethodsBuilder for ZoneViewMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ZoneViewMethods<'a, C, A> {} -impl<'a, C, NC, A> ZoneViewMethods<'a, C, NC, A> { +impl<'a, C, A> ZoneViewMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -799,7 +795,7 @@ impl<'a, C, NC, A> ZoneViewMethods<'a, C, NC, A> { /// * `project` - The project name of the resource view. /// * `zone` - The zone name of the resource view. /// * `resourceView` - The name of the resource view. - pub fn remove_resources(&self, request: &ZoneViewsRemoveResourcesRequest, project: &str, zone: &str, resource_view: &str) -> ZoneViewRemoveResourceCall<'a, C, NC, A> { + pub fn remove_resources(&self, request: &ZoneViewsRemoveResourcesRequest, project: &str, zone: &str, resource_view: &str) -> ZoneViewRemoveResourceCall<'a, C, A> { ZoneViewRemoveResourceCall { hub: self.hub, _request: request.clone(), @@ -822,7 +818,7 @@ impl<'a, C, NC, A> ZoneViewMethods<'a, C, NC, A> { /// * `project` - The project name of the resource view. /// * `zone` - The zone name of the resource view. /// * `resourceView` - The name of the resource view. - pub fn add_resources(&self, request: &ZoneViewsAddResourcesRequest, project: &str, zone: &str, resource_view: &str) -> ZoneViewAddResourceCall<'a, C, NC, A> { + pub fn add_resources(&self, request: &ZoneViewsAddResourcesRequest, project: &str, zone: &str, resource_view: &str) -> ZoneViewAddResourceCall<'a, C, A> { ZoneViewAddResourceCall { hub: self.hub, _request: request.clone(), @@ -844,7 +840,7 @@ impl<'a, C, NC, A> ZoneViewMethods<'a, C, NC, A> { /// * `project` - The project name of the resource view. /// * `zone` - The zone name of the resource view. /// * `resourceView` - The name of the resource view. - pub fn list_resources(&self, project: &str, zone: &str, resource_view: &str) -> ZoneViewListResourceCall<'a, C, NC, A> { + pub fn list_resources(&self, project: &str, zone: &str, resource_view: &str) -> ZoneViewListResourceCall<'a, C, A> { ZoneViewListResourceCall { hub: self.hub, _project: project.to_string(), @@ -870,7 +866,7 @@ impl<'a, C, NC, A> ZoneViewMethods<'a, C, NC, A> { /// * `project` - The project name of the resource view. /// * `zone` - The zone name of the resource view. /// * `resourceView` - The name of the resource view. - pub fn get(&self, project: &str, zone: &str, resource_view: &str) -> ZoneViewGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, zone: &str, resource_view: &str) -> ZoneViewGetCall<'a, C, A> { ZoneViewGetCall { hub: self.hub, _project: project.to_string(), @@ -890,7 +886,7 @@ impl<'a, C, NC, A> ZoneViewMethods<'a, C, NC, A> { /// /// * `project` - The project name of the resource view. /// * `zone` - The zone name of the resource view. - pub fn list(&self, project: &str, zone: &str) -> ZoneViewListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, zone: &str) -> ZoneViewListCall<'a, C, A> { ZoneViewListCall { hub: self.hub, _project: project.to_string(), @@ -912,7 +908,7 @@ impl<'a, C, NC, A> ZoneViewMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - The project name of the resource view. /// * `zone` - The zone name of the resource view. - pub fn insert(&self, request: &ResourceView, project: &str, zone: &str) -> ZoneViewInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &ResourceView, project: &str, zone: &str) -> ZoneViewInsertCall<'a, C, A> { ZoneViewInsertCall { hub: self.hub, _request: request.clone(), @@ -933,7 +929,7 @@ impl<'a, C, NC, A> ZoneViewMethods<'a, C, NC, A> { /// * `project` - The project name of the resource view. /// * `zone` - The zone name of the resource view. /// * `resourceView` - The name of the resource view. - pub fn delete(&self, project: &str, zone: &str, resource_view: &str) -> ZoneViewDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, zone: &str, resource_view: &str) -> ZoneViewDeleteCall<'a, C, A> { ZoneViewDeleteCall { hub: self.hub, _project: project.to_string(), @@ -955,7 +951,7 @@ impl<'a, C, NC, A> ZoneViewMethods<'a, C, NC, A> { /// * `project` - The project name of the resource view. /// * `zone` - The zone name of the resource view. /// * `resourceView` - The name of the resource view. - pub fn set_service(&self, request: &ZoneViewsSetServiceRequest, project: &str, zone: &str, resource_view: &str) -> ZoneViewSetServiceCall<'a, C, NC, A> { + pub fn set_service(&self, request: &ZoneViewsSetServiceRequest, project: &str, zone: &str, resource_view: &str) -> ZoneViewSetServiceCall<'a, C, A> { ZoneViewSetServiceCall { hub: self.hub, _request: request.clone(), @@ -977,7 +973,7 @@ impl<'a, C, NC, A> ZoneViewMethods<'a, C, NC, A> { /// * `project` - The project name of the resource view. /// * `zone` - The zone name of the resource view. /// * `resourceView` - The name of the resource view. - pub fn get_service(&self, project: &str, zone: &str, resource_view: &str) -> ZoneViewGetServiceCall<'a, C, NC, A> { + pub fn get_service(&self, project: &str, zone: &str, resource_view: &str) -> ZoneViewGetServiceCall<'a, C, A> { ZoneViewGetServiceCall { hub: self.hub, _project: project.to_string(), @@ -1021,15 +1017,15 @@ impl<'a, C, NC, A> ZoneViewMethods<'a, C, NC, A> { /// let rb = hub.zone_operations(); /// # } /// ``` -pub struct ZoneOperationMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneOperationMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Resourceviews, + hub: &'a Resourceviews, } -impl<'a, C, NC, A> MethodsBuilder for ZoneOperationMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ZoneOperationMethods<'a, C, A> {} -impl<'a, C, NC, A> ZoneOperationMethods<'a, C, NC, A> { +impl<'a, C, A> ZoneOperationMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1040,7 +1036,7 @@ impl<'a, C, NC, A> ZoneOperationMethods<'a, C, NC, A> { /// * `project` - Name of the project scoping this request. /// * `zone` - Name of the zone scoping this request. /// * `operation` - Name of the operation resource to return. - pub fn get(&self, project: &str, zone: &str, operation: &str) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, zone: &str, operation: &str) -> ZoneOperationGetCall<'a, C, A> { ZoneOperationGetCall { hub: self.hub, _project: project.to_string(), @@ -1060,7 +1056,7 @@ impl<'a, C, NC, A> ZoneOperationMethods<'a, C, NC, A> { /// /// * `project` - Name of the project scoping this request. /// * `zone` - Name of the zone scoping this request. - pub fn list(&self, project: &str, zone: &str) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, zone: &str) -> ZoneOperationListCall<'a, C, A> { ZoneOperationListCall { hub: self.hub, _project: project.to_string(), @@ -1119,10 +1115,10 @@ impl<'a, C, NC, A> ZoneOperationMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct ZoneViewRemoveResourceCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneViewRemoveResourceCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Resourceviews, + hub: &'a Resourceviews, _request: ZoneViewsRemoveResourcesRequest, _project: String, _zone: String, @@ -1132,9 +1128,9 @@ pub struct ZoneViewRemoveResourceCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ZoneViewRemoveResourceCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ZoneViewRemoveResourceCall<'a, C, A> {} -impl<'a, C, NC, A> ZoneViewRemoveResourceCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ZoneViewRemoveResourceCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1275,7 +1271,7 @@ impl<'a, C, NC, A> ZoneViewRemoveResourceCall<'a, C, NC, A> where NC: hyper::net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ZoneViewsRemoveResourcesRequest) -> ZoneViewRemoveResourceCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ZoneViewsRemoveResourcesRequest) -> ZoneViewRemoveResourceCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1285,7 +1281,7 @@ impl<'a, C, NC, A> ZoneViewRemoveResourceCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The project name of the resource view. - pub fn project(mut self, new_value: &str) -> ZoneViewRemoveResourceCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ZoneViewRemoveResourceCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1295,7 +1291,7 @@ impl<'a, C, NC, A> ZoneViewRemoveResourceCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The zone name of the resource view. - pub fn zone(mut self, new_value: &str) -> ZoneViewRemoveResourceCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> ZoneViewRemoveResourceCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -1305,7 +1301,7 @@ impl<'a, C, NC, A> ZoneViewRemoveResourceCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The name of the resource view. - pub fn resource_view(mut self, new_value: &str) -> ZoneViewRemoveResourceCall<'a, C, NC, A> { + pub fn resource_view(mut self, new_value: &str) -> ZoneViewRemoveResourceCall<'a, C, A> { self._resource_view = new_value.to_string(); self } @@ -1316,7 +1312,7 @@ impl<'a, C, NC, A> ZoneViewRemoveResourceCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneViewRemoveResourceCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneViewRemoveResourceCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1337,7 +1333,7 @@ impl<'a, C, NC, A> ZoneViewRemoveResourceCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ZoneViewRemoveResourceCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ZoneViewRemoveResourceCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1354,7 +1350,7 @@ impl<'a, C, NC, A> ZoneViewRemoveResourceCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ZoneViewRemoveResourceCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ZoneViewRemoveResourceCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1398,10 +1394,10 @@ impl<'a, C, NC, A> ZoneViewRemoveResourceCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct ZoneViewAddResourceCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneViewAddResourceCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Resourceviews, + hub: &'a Resourceviews, _request: ZoneViewsAddResourcesRequest, _project: String, _zone: String, @@ -1411,9 +1407,9 @@ pub struct ZoneViewAddResourceCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ZoneViewAddResourceCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ZoneViewAddResourceCall<'a, C, A> {} -impl<'a, C, NC, A> ZoneViewAddResourceCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ZoneViewAddResourceCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1554,7 +1550,7 @@ impl<'a, C, NC, A> ZoneViewAddResourceCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ZoneViewsAddResourcesRequest) -> ZoneViewAddResourceCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ZoneViewsAddResourcesRequest) -> ZoneViewAddResourceCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1564,7 +1560,7 @@ impl<'a, C, NC, A> ZoneViewAddResourceCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The project name of the resource view. - pub fn project(mut self, new_value: &str) -> ZoneViewAddResourceCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ZoneViewAddResourceCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1574,7 +1570,7 @@ impl<'a, C, NC, A> ZoneViewAddResourceCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The zone name of the resource view. - pub fn zone(mut self, new_value: &str) -> ZoneViewAddResourceCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> ZoneViewAddResourceCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -1584,7 +1580,7 @@ impl<'a, C, NC, A> ZoneViewAddResourceCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The name of the resource view. - pub fn resource_view(mut self, new_value: &str) -> ZoneViewAddResourceCall<'a, C, NC, A> { + pub fn resource_view(mut self, new_value: &str) -> ZoneViewAddResourceCall<'a, C, A> { self._resource_view = new_value.to_string(); self } @@ -1595,7 +1591,7 @@ impl<'a, C, NC, A> ZoneViewAddResourceCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneViewAddResourceCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneViewAddResourceCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1616,7 +1612,7 @@ impl<'a, C, NC, A> ZoneViewAddResourceCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ZoneViewAddResourceCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ZoneViewAddResourceCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1633,7 +1629,7 @@ impl<'a, C, NC, A> ZoneViewAddResourceCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ZoneViewAddResourceCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ZoneViewAddResourceCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1676,10 +1672,10 @@ impl<'a, C, NC, A> ZoneViewAddResourceCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct ZoneViewListResourceCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneViewListResourceCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Resourceviews, + hub: &'a Resourceviews, _project: String, _zone: String, _resource_view: String, @@ -1693,9 +1689,9 @@ pub struct ZoneViewListResourceCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ZoneViewListResourceCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ZoneViewListResourceCall<'a, C, A> {} -impl<'a, C, NC, A> ZoneViewListResourceCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ZoneViewListResourceCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1844,7 +1840,7 @@ impl<'a, C, NC, A> ZoneViewListResourceCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The project name of the resource view. - pub fn project(mut self, new_value: &str) -> ZoneViewListResourceCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ZoneViewListResourceCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1854,7 +1850,7 @@ impl<'a, C, NC, A> ZoneViewListResourceCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The zone name of the resource view. - pub fn zone(mut self, new_value: &str) -> ZoneViewListResourceCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> ZoneViewListResourceCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -1864,7 +1860,7 @@ impl<'a, C, NC, A> ZoneViewListResourceCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The name of the resource view. - pub fn resource_view(mut self, new_value: &str) -> ZoneViewListResourceCall<'a, C, NC, A> { + pub fn resource_view(mut self, new_value: &str) -> ZoneViewListResourceCall<'a, C, A> { self._resource_view = new_value.to_string(); self } @@ -1872,7 +1868,7 @@ impl<'a, C, NC, A> ZoneViewListResourceCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// The service name to return in the response. It is optional and if it is not set, all the service end points will be returned. - pub fn service_name(mut self, new_value: &str) -> ZoneViewListResourceCall<'a, C, NC, A> { + pub fn service_name(mut self, new_value: &str) -> ZoneViewListResourceCall<'a, C, A> { self._service_name = Some(new_value.to_string()); self } @@ -1880,7 +1876,7 @@ impl<'a, C, NC, A> ZoneViewListResourceCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// Specifies a nextPageToken returned by a previous list request. This token can be used to request the next page of results from a previous list request. - pub fn page_token(mut self, new_value: &str) -> ZoneViewListResourceCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ZoneViewListResourceCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -1888,7 +1884,7 @@ impl<'a, C, NC, A> ZoneViewListResourceCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// Maximum count of results to be returned. Acceptable values are 0 to 5000, inclusive. (Default: 5000) - pub fn max_results(mut self, new_value: i32) -> ZoneViewListResourceCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ZoneViewListResourceCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -1896,7 +1892,7 @@ impl<'a, C, NC, A> ZoneViewListResourceCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// The state of the instance to list. By default, it lists all instances. - pub fn list_state(mut self, new_value: &str) -> ZoneViewListResourceCall<'a, C, NC, A> { + pub fn list_state(mut self, new_value: &str) -> ZoneViewListResourceCall<'a, C, A> { self._list_state = Some(new_value.to_string()); self } @@ -1904,7 +1900,7 @@ impl<'a, C, NC, A> ZoneViewListResourceCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// The requested format of the return value. It can be URL or URL_PORT. A JSON object will be included in the response based on the format. The default format is NONE, which results in no JSON in the response. - pub fn format(mut self, new_value: &str) -> ZoneViewListResourceCall<'a, C, NC, A> { + pub fn format(mut self, new_value: &str) -> ZoneViewListResourceCall<'a, C, A> { self._format = Some(new_value.to_string()); self } @@ -1915,7 +1911,7 @@ impl<'a, C, NC, A> ZoneViewListResourceCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneViewListResourceCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneViewListResourceCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1936,7 +1932,7 @@ impl<'a, C, NC, A> ZoneViewListResourceCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ZoneViewListResourceCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ZoneViewListResourceCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1953,7 +1949,7 @@ impl<'a, C, NC, A> ZoneViewListResourceCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ZoneViewListResourceCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ZoneViewListResourceCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1991,10 +1987,10 @@ impl<'a, C, NC, A> ZoneViewListResourceCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct ZoneViewGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneViewGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Resourceviews, + hub: &'a Resourceviews, _project: String, _zone: String, _resource_view: String, @@ -2003,9 +1999,9 @@ pub struct ZoneViewGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ZoneViewGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ZoneViewGetCall<'a, C, A> {} -impl<'a, C, NC, A> ZoneViewGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ZoneViewGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2139,7 +2135,7 @@ impl<'a, C, NC, A> ZoneViewGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The project name of the resource view. - pub fn project(mut self, new_value: &str) -> ZoneViewGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ZoneViewGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2149,7 +2145,7 @@ impl<'a, C, NC, A> ZoneViewGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The zone name of the resource view. - pub fn zone(mut self, new_value: &str) -> ZoneViewGetCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> ZoneViewGetCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -2159,7 +2155,7 @@ impl<'a, C, NC, A> ZoneViewGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The name of the resource view. - pub fn resource_view(mut self, new_value: &str) -> ZoneViewGetCall<'a, C, NC, A> { + pub fn resource_view(mut self, new_value: &str) -> ZoneViewGetCall<'a, C, A> { self._resource_view = new_value.to_string(); self } @@ -2170,7 +2166,7 @@ impl<'a, C, NC, A> ZoneViewGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneViewGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneViewGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2191,7 +2187,7 @@ impl<'a, C, NC, A> ZoneViewGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ZoneViewGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ZoneViewGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2208,7 +2204,7 @@ impl<'a, C, NC, A> ZoneViewGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ZoneViewGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ZoneViewGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2248,10 +2244,10 @@ impl<'a, C, NC, A> ZoneViewGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct ZoneViewListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneViewListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Resourceviews, + hub: &'a Resourceviews, _project: String, _zone: String, _page_token: Option, @@ -2261,9 +2257,9 @@ pub struct ZoneViewListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ZoneViewListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ZoneViewListCall<'a, C, A> {} -impl<'a, C, NC, A> ZoneViewListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ZoneViewListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2402,7 +2398,7 @@ impl<'a, C, NC, A> ZoneViewListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The project name of the resource view. - pub fn project(mut self, new_value: &str) -> ZoneViewListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ZoneViewListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2412,7 +2408,7 @@ impl<'a, C, NC, A> ZoneViewListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The zone name of the resource view. - pub fn zone(mut self, new_value: &str) -> ZoneViewListCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> ZoneViewListCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -2420,7 +2416,7 @@ impl<'a, C, NC, A> ZoneViewListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Specifies a nextPageToken returned by a previous list request. This token can be used to request the next page of results from a previous list request. - pub fn page_token(mut self, new_value: &str) -> ZoneViewListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ZoneViewListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2428,7 +2424,7 @@ impl<'a, C, NC, A> ZoneViewListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Maximum count of results to be returned. Acceptable values are 0 to 5000, inclusive. (Default: 5000) - pub fn max_results(mut self, new_value: i32) -> ZoneViewListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ZoneViewListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2439,7 +2435,7 @@ impl<'a, C, NC, A> ZoneViewListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneViewListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneViewListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2460,7 +2456,7 @@ impl<'a, C, NC, A> ZoneViewListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ZoneViewListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ZoneViewListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2477,7 +2473,7 @@ impl<'a, C, NC, A> ZoneViewListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ZoneViewListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ZoneViewListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2521,10 +2517,10 @@ impl<'a, C, NC, A> ZoneViewListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct ZoneViewInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneViewInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Resourceviews, + hub: &'a Resourceviews, _request: ResourceView, _project: String, _zone: String, @@ -2533,9 +2529,9 @@ pub struct ZoneViewInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ZoneViewInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ZoneViewInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ZoneViewInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ZoneViewInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2675,7 +2671,7 @@ impl<'a, C, NC, A> ZoneViewInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ResourceView) -> ZoneViewInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ResourceView) -> ZoneViewInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2685,7 +2681,7 @@ impl<'a, C, NC, A> ZoneViewInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The project name of the resource view. - pub fn project(mut self, new_value: &str) -> ZoneViewInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ZoneViewInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2695,7 +2691,7 @@ impl<'a, C, NC, A> ZoneViewInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The zone name of the resource view. - pub fn zone(mut self, new_value: &str) -> ZoneViewInsertCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> ZoneViewInsertCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -2706,7 +2702,7 @@ impl<'a, C, NC, A> ZoneViewInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneViewInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneViewInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2727,7 +2723,7 @@ impl<'a, C, NC, A> ZoneViewInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ZoneViewInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ZoneViewInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2744,7 +2740,7 @@ impl<'a, C, NC, A> ZoneViewInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ZoneViewInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ZoneViewInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2782,10 +2778,10 @@ impl<'a, C, NC, A> ZoneViewInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct ZoneViewDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneViewDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Resourceviews, + hub: &'a Resourceviews, _project: String, _zone: String, _resource_view: String, @@ -2794,9 +2790,9 @@ pub struct ZoneViewDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ZoneViewDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ZoneViewDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ZoneViewDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ZoneViewDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2930,7 +2926,7 @@ impl<'a, C, NC, A> ZoneViewDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The project name of the resource view. - pub fn project(mut self, new_value: &str) -> ZoneViewDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ZoneViewDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2940,7 +2936,7 @@ impl<'a, C, NC, A> ZoneViewDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The zone name of the resource view. - pub fn zone(mut self, new_value: &str) -> ZoneViewDeleteCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> ZoneViewDeleteCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -2950,7 +2946,7 @@ impl<'a, C, NC, A> ZoneViewDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The name of the resource view. - pub fn resource_view(mut self, new_value: &str) -> ZoneViewDeleteCall<'a, C, NC, A> { + pub fn resource_view(mut self, new_value: &str) -> ZoneViewDeleteCall<'a, C, A> { self._resource_view = new_value.to_string(); self } @@ -2961,7 +2957,7 @@ impl<'a, C, NC, A> ZoneViewDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneViewDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneViewDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2982,7 +2978,7 @@ impl<'a, C, NC, A> ZoneViewDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ZoneViewDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ZoneViewDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2999,7 +2995,7 @@ impl<'a, C, NC, A> ZoneViewDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ZoneViewDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ZoneViewDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3043,10 +3039,10 @@ impl<'a, C, NC, A> ZoneViewDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct ZoneViewSetServiceCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneViewSetServiceCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Resourceviews, + hub: &'a Resourceviews, _request: ZoneViewsSetServiceRequest, _project: String, _zone: String, @@ -3056,9 +3052,9 @@ pub struct ZoneViewSetServiceCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ZoneViewSetServiceCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ZoneViewSetServiceCall<'a, C, A> {} -impl<'a, C, NC, A> ZoneViewSetServiceCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ZoneViewSetServiceCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3199,7 +3195,7 @@ impl<'a, C, NC, A> ZoneViewSetServiceCall<'a, C, NC, A> where NC: hyper::net::Ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ZoneViewsSetServiceRequest) -> ZoneViewSetServiceCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ZoneViewsSetServiceRequest) -> ZoneViewSetServiceCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3209,7 +3205,7 @@ impl<'a, C, NC, A> ZoneViewSetServiceCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The project name of the resource view. - pub fn project(mut self, new_value: &str) -> ZoneViewSetServiceCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ZoneViewSetServiceCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -3219,7 +3215,7 @@ impl<'a, C, NC, A> ZoneViewSetServiceCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The zone name of the resource view. - pub fn zone(mut self, new_value: &str) -> ZoneViewSetServiceCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> ZoneViewSetServiceCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -3229,7 +3225,7 @@ impl<'a, C, NC, A> ZoneViewSetServiceCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The name of the resource view. - pub fn resource_view(mut self, new_value: &str) -> ZoneViewSetServiceCall<'a, C, NC, A> { + pub fn resource_view(mut self, new_value: &str) -> ZoneViewSetServiceCall<'a, C, A> { self._resource_view = new_value.to_string(); self } @@ -3240,7 +3236,7 @@ impl<'a, C, NC, A> ZoneViewSetServiceCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneViewSetServiceCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneViewSetServiceCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3261,7 +3257,7 @@ impl<'a, C, NC, A> ZoneViewSetServiceCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ZoneViewSetServiceCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ZoneViewSetServiceCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3278,7 +3274,7 @@ impl<'a, C, NC, A> ZoneViewSetServiceCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ZoneViewSetServiceCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ZoneViewSetServiceCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3317,10 +3313,10 @@ impl<'a, C, NC, A> ZoneViewSetServiceCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct ZoneViewGetServiceCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneViewGetServiceCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Resourceviews, + hub: &'a Resourceviews, _project: String, _zone: String, _resource_view: String, @@ -3330,9 +3326,9 @@ pub struct ZoneViewGetServiceCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ZoneViewGetServiceCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ZoneViewGetServiceCall<'a, C, A> {} -impl<'a, C, NC, A> ZoneViewGetServiceCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ZoneViewGetServiceCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3469,7 +3465,7 @@ impl<'a, C, NC, A> ZoneViewGetServiceCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The project name of the resource view. - pub fn project(mut self, new_value: &str) -> ZoneViewGetServiceCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ZoneViewGetServiceCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -3479,7 +3475,7 @@ impl<'a, C, NC, A> ZoneViewGetServiceCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The zone name of the resource view. - pub fn zone(mut self, new_value: &str) -> ZoneViewGetServiceCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> ZoneViewGetServiceCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -3489,7 +3485,7 @@ impl<'a, C, NC, A> ZoneViewGetServiceCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The name of the resource view. - pub fn resource_view(mut self, new_value: &str) -> ZoneViewGetServiceCall<'a, C, NC, A> { + pub fn resource_view(mut self, new_value: &str) -> ZoneViewGetServiceCall<'a, C, A> { self._resource_view = new_value.to_string(); self } @@ -3497,7 +3493,7 @@ impl<'a, C, NC, A> ZoneViewGetServiceCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// The name of the resource if user wants to get the service information of the resource. - pub fn resource_name(mut self, new_value: &str) -> ZoneViewGetServiceCall<'a, C, NC, A> { + pub fn resource_name(mut self, new_value: &str) -> ZoneViewGetServiceCall<'a, C, A> { self._resource_name = Some(new_value.to_string()); self } @@ -3508,7 +3504,7 @@ impl<'a, C, NC, A> ZoneViewGetServiceCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneViewGetServiceCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneViewGetServiceCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3529,7 +3525,7 @@ impl<'a, C, NC, A> ZoneViewGetServiceCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ZoneViewGetServiceCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ZoneViewGetServiceCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3546,7 +3542,7 @@ impl<'a, C, NC, A> ZoneViewGetServiceCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ZoneViewGetServiceCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ZoneViewGetServiceCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3584,10 +3580,10 @@ impl<'a, C, NC, A> ZoneViewGetServiceCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct ZoneOperationGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneOperationGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Resourceviews, + hub: &'a Resourceviews, _project: String, _zone: String, _operation: String, @@ -3596,9 +3592,9 @@ pub struct ZoneOperationGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ZoneOperationGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ZoneOperationGetCall<'a, C, A> {} -impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ZoneOperationGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3732,7 +3728,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -3742,7 +3738,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Name of the zone scoping this request. - pub fn zone(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -3752,7 +3748,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// Name of the operation resource to return. - pub fn operation(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn operation(mut self, new_value: &str) -> ZoneOperationGetCall<'a, C, A> { self._operation = new_value.to_string(); self } @@ -3763,7 +3759,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneOperationGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneOperationGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3784,7 +3780,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ZoneOperationGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ZoneOperationGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3801,7 +3797,7 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ZoneOperationGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ZoneOperationGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3842,10 +3838,10 @@ impl<'a, C, NC, A> ZoneOperationGetCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct ZoneOperationListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ZoneOperationListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Resourceviews, + hub: &'a Resourceviews, _project: String, _zone: String, _page_token: Option, @@ -3856,9 +3852,9 @@ pub struct ZoneOperationListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ZoneOperationListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ZoneOperationListCall<'a, C, A> {} -impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ZoneOperationListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4000,7 +3996,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Name of the project scoping this request. - pub fn project(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -4010,7 +4006,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// Name of the zone scoping this request. - pub fn zone(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn zone(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, A> { self._zone = new_value.to_string(); self } @@ -4018,7 +4014,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Optional. Tag returned by a previous list request truncated by maxResults. Used to continue a previous list request. - pub fn page_token(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -4026,7 +4022,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Optional. Maximum count of results to be returned. Maximum value is 500 and default value is 500. - pub fn max_results(mut self, new_value: u32) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> ZoneOperationListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -4034,7 +4030,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// Optional. Filter expression for filtering listed resources. - pub fn filter(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn filter(mut self, new_value: &str) -> ZoneOperationListCall<'a, C, A> { self._filter = Some(new_value.to_string()); self } @@ -4045,7 +4041,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneOperationListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ZoneOperationListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4066,7 +4062,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ZoneOperationListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ZoneOperationListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4083,7 +4079,7 @@ impl<'a, C, NC, A> ZoneOperationListCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ZoneOperationListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ZoneOperationListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/siteverification1/Cargo.toml b/gen/siteverification1/Cargo.toml index 7353baa8b92..82b92d9e65b 100644 --- a/gen/siteverification1/Cargo.toml +++ b/gen/siteverification1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-siteverification1" -version = "0.1.4+20131007" +version = "0.1.5+20131007" authors = ["Sebastian Thiel "] description = "A complete library to interact with siteVerification (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/siteverification1" homepage = "https://developers.google.com/site-verification/" -documentation = "http://byron.github.io/google-apis-rs/google-siteverification1" +documentation = "http://byron.github.io/google-apis-rs/google_siteverification1" license = "MIT" keywords = ["siteVerification", "google", "protocol", "web", "api"] diff --git a/gen/siteverification1/README.md b/gen/siteverification1/README.md index a715fdac145..778639ffc5e 100644 --- a/gen/siteverification1/README.md +++ b/gen/siteverification1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-siteverification1` library allows access to all features of the *Google siteVerification* service. -This documentation was generated from *siteVerification* crate version *0.1.4+20131007*, where *20131007* is the exact revision of the *siteVerification:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *siteVerification* crate version *0.1.5+20131007*, where *20131007* is the exact revision of the *siteVerification:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *siteVerification* *v1* API can be found at the [official documentation site](https://developers.google.com/site-verification/). diff --git a/gen/siteverification1/src/cmn.rs b/gen/siteverification1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/siteverification1/src/cmn.rs +++ b/gen/siteverification1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/siteverification1/src/lib.rs b/gen/siteverification1/src/lib.rs index 60b9880f2ea..45119ad24ad 100644 --- a/gen/siteverification1/src/lib.rs +++ b/gen/siteverification1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *siteVerification* crate version *0.1.4+20131007*, where *20131007* is the exact revision of the *siteVerification:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *siteVerification* crate version *0.1.5+20131007*, where *20131007* is the exact revision of the *siteVerification:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *siteVerification* *v1* API can be found at the //! [official documentation site](https://developers.google.com/site-verification/). @@ -197,7 +197,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -298,34 +297,31 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct SiteVerification { +pub struct SiteVerification { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for SiteVerification {} +impl<'a, C, A> Hub for SiteVerification {} -impl<'a, C, NC, A> SiteVerification - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SiteVerification + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> SiteVerification { + pub fn new(client: C, authenticator: A) -> SiteVerification { SiteVerification { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn web_resource(&'a self) -> WebResourceMethods<'a, C, NC, A> { + pub fn web_resource(&'a self) -> WebResourceMethods<'a, C, A> { WebResourceMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -491,15 +487,15 @@ impl ResponseResult for SiteVerificationWebResourceGettokenResponse {} /// let rb = hub.web_resource(); /// # } /// ``` -pub struct WebResourceMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct WebResourceMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SiteVerification, + hub: &'a SiteVerification, } -impl<'a, C, NC, A> MethodsBuilder for WebResourceMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for WebResourceMethods<'a, C, A> {} -impl<'a, C, NC, A> WebResourceMethods<'a, C, NC, A> { +impl<'a, C, A> WebResourceMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -508,7 +504,7 @@ impl<'a, C, NC, A> WebResourceMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The id of a verified site or domain. - pub fn get(&self, id: &str) -> WebResourceGetCall<'a, C, NC, A> { + pub fn get(&self, id: &str) -> WebResourceGetCall<'a, C, A> { WebResourceGetCall { hub: self.hub, _id: id.to_string(), @@ -526,7 +522,7 @@ impl<'a, C, NC, A> WebResourceMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The id of a verified site or domain. - pub fn patch(&self, request: &SiteVerificationWebResourceResource, id: &str) -> WebResourcePatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &SiteVerificationWebResourceResource, id: &str) -> WebResourcePatchCall<'a, C, A> { WebResourcePatchCall { hub: self.hub, _request: request.clone(), @@ -540,7 +536,7 @@ impl<'a, C, NC, A> WebResourceMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Get the list of your verified websites and domains. - pub fn list(&self) -> WebResourceListCall<'a, C, NC, A> { + pub fn list(&self) -> WebResourceListCall<'a, C, A> { WebResourceListCall { hub: self.hub, _delegate: Default::default(), @@ -556,7 +552,7 @@ impl<'a, C, NC, A> WebResourceMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The id of a verified site or domain. - pub fn delete(&self, id: &str) -> WebResourceDeleteCall<'a, C, NC, A> { + pub fn delete(&self, id: &str) -> WebResourceDeleteCall<'a, C, A> { WebResourceDeleteCall { hub: self.hub, _id: id.to_string(), @@ -573,7 +569,7 @@ impl<'a, C, NC, A> WebResourceMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn get_token(&self, request: &SiteVerificationWebResourceGettokenRequest) -> WebResourceGetTokenCall<'a, C, NC, A> { + pub fn get_token(&self, request: &SiteVerificationWebResourceGettokenRequest) -> WebResourceGetTokenCall<'a, C, A> { WebResourceGetTokenCall { hub: self.hub, _request: request.clone(), @@ -591,7 +587,7 @@ impl<'a, C, NC, A> WebResourceMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `id` - The id of a verified site or domain. - pub fn update(&self, request: &SiteVerificationWebResourceResource, id: &str) -> WebResourceUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &SiteVerificationWebResourceResource, id: &str) -> WebResourceUpdateCall<'a, C, A> { WebResourceUpdateCall { hub: self.hub, _request: request.clone(), @@ -610,7 +606,7 @@ impl<'a, C, NC, A> WebResourceMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `verificationMethod` - The method to use for verifying a site or domain. - pub fn insert(&self, request: &SiteVerificationWebResourceResource, verification_method: &str) -> WebResourceInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &SiteVerificationWebResourceResource, verification_method: &str) -> WebResourceInsertCall<'a, C, A> { WebResourceInsertCall { hub: self.hub, _request: request.clone(), @@ -660,19 +656,19 @@ impl<'a, C, NC, A> WebResourceMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct WebResourceGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct WebResourceGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SiteVerification, + hub: &'a SiteVerification, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for WebResourceGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for WebResourceGetCall<'a, C, A> {} -impl<'a, C, NC, A> WebResourceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> WebResourceGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -804,7 +800,7 @@ impl<'a, C, NC, A> WebResourceGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The id of a verified site or domain. - pub fn id(mut self, new_value: &str) -> WebResourceGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> WebResourceGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -815,7 +811,7 @@ impl<'a, C, NC, A> WebResourceGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> WebResourceGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> WebResourceGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -836,7 +832,7 @@ impl<'a, C, NC, A> WebResourceGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> WebResourceGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> WebResourceGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -853,7 +849,7 @@ impl<'a, C, NC, A> WebResourceGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> WebResourceGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> WebResourceGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -897,10 +893,10 @@ impl<'a, C, NC, A> WebResourceGetCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct WebResourcePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct WebResourcePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SiteVerification, + hub: &'a SiteVerification, _request: SiteVerificationWebResourceResource, _id: String, _delegate: Option<&'a mut Delegate>, @@ -908,9 +904,9 @@ pub struct WebResourcePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for WebResourcePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for WebResourcePatchCall<'a, C, A> {} -impl<'a, C, NC, A> WebResourcePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> WebResourcePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1049,7 +1045,7 @@ impl<'a, C, NC, A> WebResourcePatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &SiteVerificationWebResourceResource) -> WebResourcePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &SiteVerificationWebResourceResource) -> WebResourcePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1059,7 +1055,7 @@ impl<'a, C, NC, A> WebResourcePatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The id of a verified site or domain. - pub fn id(mut self, new_value: &str) -> WebResourcePatchCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> WebResourcePatchCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -1070,7 +1066,7 @@ impl<'a, C, NC, A> WebResourcePatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> WebResourcePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> WebResourcePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1091,7 +1087,7 @@ impl<'a, C, NC, A> WebResourcePatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> WebResourcePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> WebResourcePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1108,7 +1104,7 @@ impl<'a, C, NC, A> WebResourcePatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> WebResourcePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> WebResourcePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1146,18 +1142,18 @@ impl<'a, C, NC, A> WebResourcePatchCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct WebResourceListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct WebResourceListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SiteVerification, + hub: &'a SiteVerification, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for WebResourceListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for WebResourceListCall<'a, C, A> {} -impl<'a, C, NC, A> WebResourceListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> WebResourceListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1265,7 +1261,7 @@ impl<'a, C, NC, A> WebResourceListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> WebResourceListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> WebResourceListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1286,7 +1282,7 @@ impl<'a, C, NC, A> WebResourceListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> WebResourceListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> WebResourceListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1303,7 +1299,7 @@ impl<'a, C, NC, A> WebResourceListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> WebResourceListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> WebResourceListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1341,19 +1337,19 @@ impl<'a, C, NC, A> WebResourceListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct WebResourceDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct WebResourceDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SiteVerification, + hub: &'a SiteVerification, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for WebResourceDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for WebResourceDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> WebResourceDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> WebResourceDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1474,7 +1470,7 @@ impl<'a, C, NC, A> WebResourceDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The id of a verified site or domain. - pub fn id(mut self, new_value: &str) -> WebResourceDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> WebResourceDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -1485,7 +1481,7 @@ impl<'a, C, NC, A> WebResourceDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> WebResourceDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> WebResourceDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1506,7 +1502,7 @@ impl<'a, C, NC, A> WebResourceDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> WebResourceDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> WebResourceDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1523,7 +1519,7 @@ impl<'a, C, NC, A> WebResourceDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> WebResourceDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> WebResourceDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1567,19 +1563,19 @@ impl<'a, C, NC, A> WebResourceDeleteCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct WebResourceGetTokenCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct WebResourceGetTokenCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SiteVerification, + hub: &'a SiteVerification, _request: SiteVerificationWebResourceGettokenRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for WebResourceGetTokenCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for WebResourceGetTokenCall<'a, C, A> {} -impl<'a, C, NC, A> WebResourceGetTokenCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> WebResourceGetTokenCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1693,7 +1689,7 @@ impl<'a, C, NC, A> WebResourceGetTokenCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &SiteVerificationWebResourceGettokenRequest) -> WebResourceGetTokenCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &SiteVerificationWebResourceGettokenRequest) -> WebResourceGetTokenCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1704,7 +1700,7 @@ impl<'a, C, NC, A> WebResourceGetTokenCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> WebResourceGetTokenCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> WebResourceGetTokenCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1725,7 +1721,7 @@ impl<'a, C, NC, A> WebResourceGetTokenCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> WebResourceGetTokenCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> WebResourceGetTokenCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1742,7 +1738,7 @@ impl<'a, C, NC, A> WebResourceGetTokenCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> WebResourceGetTokenCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> WebResourceGetTokenCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1786,10 +1782,10 @@ impl<'a, C, NC, A> WebResourceGetTokenCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct WebResourceUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct WebResourceUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SiteVerification, + hub: &'a SiteVerification, _request: SiteVerificationWebResourceResource, _id: String, _delegate: Option<&'a mut Delegate>, @@ -1797,9 +1793,9 @@ pub struct WebResourceUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for WebResourceUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for WebResourceUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> WebResourceUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> WebResourceUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1938,7 +1934,7 @@ impl<'a, C, NC, A> WebResourceUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &SiteVerificationWebResourceResource) -> WebResourceUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &SiteVerificationWebResourceResource) -> WebResourceUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1948,7 +1944,7 @@ impl<'a, C, NC, A> WebResourceUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The id of a verified site or domain. - pub fn id(mut self, new_value: &str) -> WebResourceUpdateCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> WebResourceUpdateCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -1959,7 +1955,7 @@ impl<'a, C, NC, A> WebResourceUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> WebResourceUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> WebResourceUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1980,7 +1976,7 @@ impl<'a, C, NC, A> WebResourceUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> WebResourceUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> WebResourceUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1997,7 +1993,7 @@ impl<'a, C, NC, A> WebResourceUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> WebResourceUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> WebResourceUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2041,10 +2037,10 @@ impl<'a, C, NC, A> WebResourceUpdateCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct WebResourceInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct WebResourceInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SiteVerification, + hub: &'a SiteVerification, _request: SiteVerificationWebResourceResource, _verification_method: String, _delegate: Option<&'a mut Delegate>, @@ -2052,9 +2048,9 @@ pub struct WebResourceInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for WebResourceInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for WebResourceInsertCall<'a, C, A> {} -impl<'a, C, NC, A> WebResourceInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> WebResourceInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2169,7 +2165,7 @@ impl<'a, C, NC, A> WebResourceInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &SiteVerificationWebResourceResource) -> WebResourceInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &SiteVerificationWebResourceResource) -> WebResourceInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2179,7 +2175,7 @@ impl<'a, C, NC, A> WebResourceInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The method to use for verifying a site or domain. - pub fn verification_method(mut self, new_value: &str) -> WebResourceInsertCall<'a, C, NC, A> { + pub fn verification_method(mut self, new_value: &str) -> WebResourceInsertCall<'a, C, A> { self._verification_method = new_value.to_string(); self } @@ -2190,7 +2186,7 @@ impl<'a, C, NC, A> WebResourceInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> WebResourceInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> WebResourceInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2211,7 +2207,7 @@ impl<'a, C, NC, A> WebResourceInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> WebResourceInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> WebResourceInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2228,7 +2224,7 @@ impl<'a, C, NC, A> WebResourceInsertCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> WebResourceInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> WebResourceInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/spectrum1_explorer/Cargo.toml b/gen/spectrum1_explorer/Cargo.toml index 15e7e95c889..f5c4fb4e6f8 100644 --- a/gen/spectrum1_explorer/Cargo.toml +++ b/gen/spectrum1_explorer/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-spectrum1_explorer" -version = "0.1.4+20150112" +version = "0.1.5+20150112" authors = ["Sebastian Thiel "] description = "A complete library to interact with spectrum (protocol v1explorer)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/spectrum1_explorer" homepage = "http://developers.google.com/spectrum" -documentation = "http://byron.github.io/google-apis-rs/google-spectrum1_explorer" +documentation = "http://byron.github.io/google-apis-rs/google_spectrum1_explorer" license = "MIT" keywords = ["spectrum", "google", "protocol", "web", "api"] diff --git a/gen/spectrum1_explorer/README.md b/gen/spectrum1_explorer/README.md index 8c919c6472d..c4e80e3bee7 100644 --- a/gen/spectrum1_explorer/README.md +++ b/gen/spectrum1_explorer/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-spectrum1_explorer` library allows access to all features of the *Google spectrum* service. -This documentation was generated from *spectrum* crate version *0.1.4+20150112*, where *20150112* is the exact revision of the *spectrum:v1explorer* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *spectrum* crate version *0.1.5+20150112*, where *20150112* is the exact revision of the *spectrum:v1explorer* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *spectrum* *v1_explorer* API can be found at the [official documentation site](http://developers.google.com/spectrum). diff --git a/gen/spectrum1_explorer/src/cmn.rs b/gen/spectrum1_explorer/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/spectrum1_explorer/src/cmn.rs +++ b/gen/spectrum1_explorer/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/spectrum1_explorer/src/lib.rs b/gen/spectrum1_explorer/src/lib.rs index 3b4d615ac03..d64c4a5acdd 100644 --- a/gen/spectrum1_explorer/src/lib.rs +++ b/gen/spectrum1_explorer/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *spectrum* crate version *0.1.4+20150112*, where *20150112* is the exact revision of the *spectrum:v1explorer* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *spectrum* crate version *0.1.5+20150112*, where *20150112* is the exact revision of the *spectrum:v1explorer* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *spectrum* *v1_explorer* API can be found at the //! [official documentation site](http://developers.google.com/spectrum). @@ -194,7 +194,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -269,34 +268,31 @@ pub use cmn::{MultiPartReader, ToParts, MethodInfo, Result, Error, CallBuilder, /// } /// # } /// ``` -pub struct Spectrum { +pub struct Spectrum { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Spectrum {} +impl<'a, C, A> Hub for Spectrum {} -impl<'a, C, NC, A> Spectrum - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Spectrum + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Spectrum { + pub fn new(client: C, authenticator: A) -> Spectrum { Spectrum { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn paws(&'a self) -> PawMethods<'a, C, NC, A> { + pub fn paws(&'a self) -> PawMethods<'a, C, A> { PawMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -1183,15 +1179,15 @@ impl RequestValue for PawsGetSpectrumRequest {} /// let rb = hub.paws(); /// # } /// ``` -pub struct PawMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PawMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Spectrum, + hub: &'a Spectrum, } -impl<'a, C, NC, A> MethodsBuilder for PawMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PawMethods<'a, C, A> {} -impl<'a, C, NC, A> PawMethods<'a, C, NC, A> { +impl<'a, C, A> PawMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1200,7 +1196,7 @@ impl<'a, C, NC, A> PawMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn notify_spectrum_use(&self, request: &PawsNotifySpectrumUseRequest) -> PawNotifySpectrumUseCall<'a, C, NC, A> { + pub fn notify_spectrum_use(&self, request: &PawsNotifySpectrumUseRequest) -> PawNotifySpectrumUseCall<'a, C, A> { PawNotifySpectrumUseCall { hub: self.hub, _request: request.clone(), @@ -1216,7 +1212,7 @@ impl<'a, C, NC, A> PawMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn register(&self, request: &PawsRegisterRequest) -> PawRegisterCall<'a, C, NC, A> { + pub fn register(&self, request: &PawsRegisterRequest) -> PawRegisterCall<'a, C, A> { PawRegisterCall { hub: self.hub, _request: request.clone(), @@ -1232,7 +1228,7 @@ impl<'a, C, NC, A> PawMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn get_spectrum(&self, request: &PawsGetSpectrumRequest) -> PawGetSpectrumCall<'a, C, NC, A> { + pub fn get_spectrum(&self, request: &PawsGetSpectrumRequest) -> PawGetSpectrumCall<'a, C, A> { PawGetSpectrumCall { hub: self.hub, _request: request.clone(), @@ -1248,7 +1244,7 @@ impl<'a, C, NC, A> PawMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn init(&self, request: &PawsInitRequest) -> PawInitCall<'a, C, NC, A> { + pub fn init(&self, request: &PawsInitRequest) -> PawInitCall<'a, C, A> { PawInitCall { hub: self.hub, _request: request.clone(), @@ -1264,7 +1260,7 @@ impl<'a, C, NC, A> PawMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn get_spectrum_batch(&self, request: &PawsGetSpectrumBatchRequest) -> PawGetSpectrumBatchCall<'a, C, NC, A> { + pub fn get_spectrum_batch(&self, request: &PawsGetSpectrumBatchRequest) -> PawGetSpectrumBatchCall<'a, C, A> { PawGetSpectrumBatchCall { hub: self.hub, _request: request.clone(), @@ -1280,7 +1276,7 @@ impl<'a, C, NC, A> PawMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn verify_device(&self, request: &PawsVerifyDeviceRequest) -> PawVerifyDeviceCall<'a, C, NC, A> { + pub fn verify_device(&self, request: &PawsVerifyDeviceRequest) -> PawVerifyDeviceCall<'a, C, A> { PawVerifyDeviceCall { hub: self.hub, _request: request.clone(), @@ -1334,18 +1330,18 @@ impl<'a, C, NC, A> PawMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct PawNotifySpectrumUseCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PawNotifySpectrumUseCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Spectrum, + hub: &'a Spectrum, _request: PawsNotifySpectrumUseRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for PawNotifySpectrumUseCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PawNotifySpectrumUseCall<'a, C, A> {} -impl<'a, C, NC, A> PawNotifySpectrumUseCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PawNotifySpectrumUseCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1457,7 +1453,7 @@ impl<'a, C, NC, A> PawNotifySpectrumUseCall<'a, C, NC, A> where NC: hyper::net:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PawsNotifySpectrumUseRequest) -> PawNotifySpectrumUseCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PawsNotifySpectrumUseRequest) -> PawNotifySpectrumUseCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1468,7 +1464,7 @@ impl<'a, C, NC, A> PawNotifySpectrumUseCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PawNotifySpectrumUseCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PawNotifySpectrumUseCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1489,7 +1485,7 @@ impl<'a, C, NC, A> PawNotifySpectrumUseCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PawNotifySpectrumUseCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PawNotifySpectrumUseCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1534,18 +1530,18 @@ impl<'a, C, NC, A> PawNotifySpectrumUseCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct PawRegisterCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PawRegisterCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Spectrum, + hub: &'a Spectrum, _request: PawsRegisterRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for PawRegisterCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PawRegisterCall<'a, C, A> {} -impl<'a, C, NC, A> PawRegisterCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PawRegisterCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1657,7 +1653,7 @@ impl<'a, C, NC, A> PawRegisterCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PawsRegisterRequest) -> PawRegisterCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PawsRegisterRequest) -> PawRegisterCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1668,7 +1664,7 @@ impl<'a, C, NC, A> PawRegisterCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PawRegisterCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PawRegisterCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1689,7 +1685,7 @@ impl<'a, C, NC, A> PawRegisterCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PawRegisterCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PawRegisterCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1734,18 +1730,18 @@ impl<'a, C, NC, A> PawRegisterCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct PawGetSpectrumCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PawGetSpectrumCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Spectrum, + hub: &'a Spectrum, _request: PawsGetSpectrumRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for PawGetSpectrumCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PawGetSpectrumCall<'a, C, A> {} -impl<'a, C, NC, A> PawGetSpectrumCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PawGetSpectrumCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1857,7 +1853,7 @@ impl<'a, C, NC, A> PawGetSpectrumCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PawsGetSpectrumRequest) -> PawGetSpectrumCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PawsGetSpectrumRequest) -> PawGetSpectrumCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1868,7 +1864,7 @@ impl<'a, C, NC, A> PawGetSpectrumCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PawGetSpectrumCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PawGetSpectrumCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1889,7 +1885,7 @@ impl<'a, C, NC, A> PawGetSpectrumCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PawGetSpectrumCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PawGetSpectrumCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1934,18 +1930,18 @@ impl<'a, C, NC, A> PawGetSpectrumCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct PawInitCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PawInitCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Spectrum, + hub: &'a Spectrum, _request: PawsInitRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for PawInitCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PawInitCall<'a, C, A> {} -impl<'a, C, NC, A> PawInitCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PawInitCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2057,7 +2053,7 @@ impl<'a, C, NC, A> PawInitCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PawsInitRequest) -> PawInitCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PawsInitRequest) -> PawInitCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2068,7 +2064,7 @@ impl<'a, C, NC, A> PawInitCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PawInitCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PawInitCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2089,7 +2085,7 @@ impl<'a, C, NC, A> PawInitCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PawInitCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PawInitCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2134,18 +2130,18 @@ impl<'a, C, NC, A> PawInitCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct PawGetSpectrumBatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PawGetSpectrumBatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Spectrum, + hub: &'a Spectrum, _request: PawsGetSpectrumBatchRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for PawGetSpectrumBatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PawGetSpectrumBatchCall<'a, C, A> {} -impl<'a, C, NC, A> PawGetSpectrumBatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PawGetSpectrumBatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2257,7 +2253,7 @@ impl<'a, C, NC, A> PawGetSpectrumBatchCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PawsGetSpectrumBatchRequest) -> PawGetSpectrumBatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PawsGetSpectrumBatchRequest) -> PawGetSpectrumBatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2268,7 +2264,7 @@ impl<'a, C, NC, A> PawGetSpectrumBatchCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PawGetSpectrumBatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PawGetSpectrumBatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2289,7 +2285,7 @@ impl<'a, C, NC, A> PawGetSpectrumBatchCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PawGetSpectrumBatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PawGetSpectrumBatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2334,18 +2330,18 @@ impl<'a, C, NC, A> PawGetSpectrumBatchCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct PawVerifyDeviceCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PawVerifyDeviceCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Spectrum, + hub: &'a Spectrum, _request: PawsVerifyDeviceRequest, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for PawVerifyDeviceCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PawVerifyDeviceCall<'a, C, A> {} -impl<'a, C, NC, A> PawVerifyDeviceCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PawVerifyDeviceCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2457,7 +2453,7 @@ impl<'a, C, NC, A> PawVerifyDeviceCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &PawsVerifyDeviceRequest) -> PawVerifyDeviceCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PawsVerifyDeviceRequest) -> PawVerifyDeviceCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2468,7 +2464,7 @@ impl<'a, C, NC, A> PawVerifyDeviceCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PawVerifyDeviceCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PawVerifyDeviceCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2489,7 +2485,7 @@ impl<'a, C, NC, A> PawVerifyDeviceCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PawVerifyDeviceCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PawVerifyDeviceCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self diff --git a/gen/sqladmin1_beta4/Cargo.toml b/gen/sqladmin1_beta4/Cargo.toml index 9a4b353045f..9f2b9b4aeb3 100644 --- a/gen/sqladmin1_beta4/Cargo.toml +++ b/gen/sqladmin1_beta4/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-sqladmin1_beta4" -version = "0.1.4+20150305" +version = "0.1.5+20150305" authors = ["Sebastian Thiel "] description = "A complete library to interact with SQL Admin (protocol v1beta4)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/sqladmin1_beta4" homepage = "https://developers.google.com/cloud-sql/docs/admin-api/" -documentation = "http://byron.github.io/google-apis-rs/google-sqladmin1_beta4" +documentation = "http://byron.github.io/google-apis-rs/google_sqladmin1_beta4" license = "MIT" keywords = ["sqladmin", "google", "protocol", "web", "api"] diff --git a/gen/sqladmin1_beta4/README.md b/gen/sqladmin1_beta4/README.md index 77029c8e5c0..3a3f0dc8ea3 100644 --- a/gen/sqladmin1_beta4/README.md +++ b/gen/sqladmin1_beta4/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-sqladmin1_beta4` library allows access to all features of the *Google SQL Admin* service. -This documentation was generated from *SQL Admin* crate version *0.1.4+20150305*, where *20150305* is the exact revision of the *sqladmin:v1beta4* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *SQL Admin* crate version *0.1.5+20150305*, where *20150305* is the exact revision of the *sqladmin:v1beta4* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *SQL Admin* *v1_beta4* API can be found at the [official documentation site](https://developers.google.com/cloud-sql/docs/admin-api/). diff --git a/gen/sqladmin1_beta4/src/cmn.rs b/gen/sqladmin1_beta4/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/sqladmin1_beta4/src/cmn.rs +++ b/gen/sqladmin1_beta4/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/sqladmin1_beta4/src/lib.rs b/gen/sqladmin1_beta4/src/lib.rs index 83c542e7e5a..0ceb43b5148 100644 --- a/gen/sqladmin1_beta4/src/lib.rs +++ b/gen/sqladmin1_beta4/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *SQL Admin* crate version *0.1.4+20150305*, where *20150305* is the exact revision of the *sqladmin:v1beta4* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *SQL Admin* crate version *0.1.5+20150305*, where *20150305* is the exact revision of the *sqladmin:v1beta4* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *SQL Admin* *v1_beta4* API can be found at the //! [official documentation site](https://developers.google.com/cloud-sql/docs/admin-api/). @@ -230,7 +230,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -331,55 +330,52 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct SQLAdmin { +pub struct SQLAdmin { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for SQLAdmin {} +impl<'a, C, A> Hub for SQLAdmin {} -impl<'a, C, NC, A> SQLAdmin - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SQLAdmin + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> SQLAdmin { + pub fn new(client: C, authenticator: A) -> SQLAdmin { SQLAdmin { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn backup_runs(&'a self) -> BackupRunMethods<'a, C, NC, A> { + pub fn backup_runs(&'a self) -> BackupRunMethods<'a, C, A> { BackupRunMethods { hub: &self } } - pub fn databases(&'a self) -> DatabaseMethods<'a, C, NC, A> { + pub fn databases(&'a self) -> DatabaseMethods<'a, C, A> { DatabaseMethods { hub: &self } } - pub fn flags(&'a self) -> FlagMethods<'a, C, NC, A> { + pub fn flags(&'a self) -> FlagMethods<'a, C, A> { FlagMethods { hub: &self } } - pub fn instances(&'a self) -> InstanceMethods<'a, C, NC, A> { + pub fn instances(&'a self) -> InstanceMethods<'a, C, A> { InstanceMethods { hub: &self } } - pub fn operations(&'a self) -> OperationMethods<'a, C, NC, A> { + pub fn operations(&'a self) -> OperationMethods<'a, C, A> { OperationMethods { hub: &self } } - pub fn ssl_certs(&'a self) -> SslCertMethods<'a, C, NC, A> { + pub fn ssl_certs(&'a self) -> SslCertMethods<'a, C, A> { SslCertMethods { hub: &self } } - pub fn tiers(&'a self) -> TierMethods<'a, C, NC, A> { + pub fn tiers(&'a self) -> TierMethods<'a, C, A> { TierMethods { hub: &self } } - pub fn users(&'a self) -> UserMethods<'a, C, NC, A> { + pub fn users(&'a self) -> UserMethods<'a, C, A> { UserMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -1536,15 +1532,15 @@ impl Part for OnPremisesConfiguration {} /// let rb = hub.operations(); /// # } /// ``` -pub struct OperationMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct OperationMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, } -impl<'a, C, NC, A> MethodsBuilder for OperationMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for OperationMethods<'a, C, A> {} -impl<'a, C, NC, A> OperationMethods<'a, C, NC, A> { +impl<'a, C, A> OperationMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1554,7 +1550,7 @@ impl<'a, C, NC, A> OperationMethods<'a, C, NC, A> { /// /// * `project` - Project ID of the project that contains the instance. /// * `instance` - Cloud SQL instance ID. This does not include the project ID. - pub fn list(&self, project: &str, instance: &str) -> OperationListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, instance: &str) -> OperationListCall<'a, C, A> { OperationListCall { hub: self.hub, _project: project.to_string(), @@ -1575,7 +1571,7 @@ impl<'a, C, NC, A> OperationMethods<'a, C, NC, A> { /// /// * `project` - Project ID of the project that contains the instance. /// * `operation` - Instance operation ID. - pub fn get(&self, project: &str, operation: &str) -> OperationGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, operation: &str) -> OperationGetCall<'a, C, A> { OperationGetCall { hub: self.hub, _project: project.to_string(), @@ -1617,15 +1613,15 @@ impl<'a, C, NC, A> OperationMethods<'a, C, NC, A> { /// let rb = hub.tiers(); /// # } /// ``` -pub struct TierMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TierMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, } -impl<'a, C, NC, A> MethodsBuilder for TierMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TierMethods<'a, C, A> {} -impl<'a, C, NC, A> TierMethods<'a, C, NC, A> { +impl<'a, C, A> TierMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1634,7 +1630,7 @@ impl<'a, C, NC, A> TierMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Project ID of the project for which to list tiers. - pub fn list(&self, project: &str) -> TierListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> TierListCall<'a, C, A> { TierListCall { hub: self.hub, _project: project.to_string(), @@ -1675,15 +1671,15 @@ impl<'a, C, NC, A> TierMethods<'a, C, NC, A> { /// let rb = hub.users(); /// # } /// ``` -pub struct UserMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, } -impl<'a, C, NC, A> MethodsBuilder for UserMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for UserMethods<'a, C, A> {} -impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { +impl<'a, C, A> UserMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1693,7 +1689,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// /// * `project` - Project ID of the project that contains the instance. /// * `instance` - Database instance ID. This does not include the project ID. - pub fn list(&self, project: &str, instance: &str) -> UserListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, instance: &str) -> UserListCall<'a, C, A> { UserListCall { hub: self.hub, _project: project.to_string(), @@ -1714,7 +1710,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// * `instance` - Database instance ID. This does not include the project ID. /// * `host` - Host of the user in the instance. /// * `name` - Name of the user in the instance. - pub fn delete(&self, project: &str, instance: &str, host: &str, name: &str) -> UserDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, instance: &str, host: &str, name: &str) -> UserDeleteCall<'a, C, A> { UserDeleteCall { hub: self.hub, _project: project.to_string(), @@ -1738,7 +1734,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// * `instance` - Database instance ID. This does not include the project ID. /// * `host` - Host of the user in the instance. /// * `name` - Name of the user in the instance. - pub fn update(&self, request: &User, project: &str, instance: &str, host: &str, name: &str) -> UserUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &User, project: &str, instance: &str, host: &str, name: &str) -> UserUpdateCall<'a, C, A> { UserUpdateCall { hub: self.hub, _request: request.clone(), @@ -1761,7 +1757,7 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Project ID of the project that contains the instance. /// * `instance` - Database instance ID. This does not include the project ID. - pub fn insert(&self, request: &User, project: &str, instance: &str) -> UserInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &User, project: &str, instance: &str) -> UserInsertCall<'a, C, A> { UserInsertCall { hub: self.hub, _request: request.clone(), @@ -1804,15 +1800,15 @@ impl<'a, C, NC, A> UserMethods<'a, C, NC, A> { /// let rb = hub.instances(); /// # } /// ``` -pub struct InstanceMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, } -impl<'a, C, NC, A> MethodsBuilder for InstanceMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for InstanceMethods<'a, C, A> {} -impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { +impl<'a, C, A> InstanceMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1822,7 +1818,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// /// * `project` - Project ID of the project that contains the instance. /// * `instance` - Cloud SQL instance ID. This does not include the project ID. - pub fn reset_ssl_config(&self, project: &str, instance: &str) -> InstanceResetSslConfigCall<'a, C, NC, A> { + pub fn reset_ssl_config(&self, project: &str, instance: &str) -> InstanceResetSslConfigCall<'a, C, A> { InstanceResetSslConfigCall { hub: self.hub, _project: project.to_string(), @@ -1841,7 +1837,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// /// * `project` - ID of the project that contains the read replica. /// * `instance` - Cloud SQL read replica instance name. - pub fn promote_replica(&self, project: &str, instance: &str) -> InstancePromoteReplicaCall<'a, C, NC, A> { + pub fn promote_replica(&self, project: &str, instance: &str) -> InstancePromoteReplicaCall<'a, C, A> { InstancePromoteReplicaCall { hub: self.hub, _project: project.to_string(), @@ -1860,7 +1856,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// /// * `project` - Project ID of the project that contains the instance. /// * `instance` - Database instance ID. This does not include the project ID. - pub fn get(&self, project: &str, instance: &str) -> InstanceGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, instance: &str) -> InstanceGetCall<'a, C, A> { InstanceGetCall { hub: self.hub, _project: project.to_string(), @@ -1880,7 +1876,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Project ID of the project that contains the instance. /// * `instance` - Cloud SQL instance ID. This does not include the project ID. - pub fn patch(&self, request: &DatabaseInstance, project: &str, instance: &str) -> InstancePatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &DatabaseInstance, project: &str, instance: &str) -> InstancePatchCall<'a, C, A> { InstancePatchCall { hub: self.hub, _request: request.clone(), @@ -1900,7 +1896,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// /// * `project` - Project ID of the project that contains the instance to be restarted. /// * `instance` - Cloud SQL instance ID. This does not include the project ID. - pub fn restart(&self, project: &str, instance: &str) -> InstanceRestartCall<'a, C, NC, A> { + pub fn restart(&self, project: &str, instance: &str) -> InstanceRestartCall<'a, C, A> { InstanceRestartCall { hub: self.hub, _project: project.to_string(), @@ -1919,7 +1915,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// /// * `project` - Project ID of the project that contains the instance to be deleted. /// * `instance` - Cloud SQL instance ID. This does not include the project ID. - pub fn delete(&self, project: &str, instance: &str) -> InstanceDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, instance: &str) -> InstanceDeleteCall<'a, C, A> { InstanceDeleteCall { hub: self.hub, _project: project.to_string(), @@ -1938,7 +1934,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// /// * `project` - ID of the project that contains the read replica. /// * `instance` - Cloud SQL read replica instance name. - pub fn stop_replica(&self, project: &str, instance: &str) -> InstanceStopReplicaCall<'a, C, NC, A> { + pub fn stop_replica(&self, project: &str, instance: &str) -> InstanceStopReplicaCall<'a, C, A> { InstanceStopReplicaCall { hub: self.hub, _project: project.to_string(), @@ -1957,7 +1953,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// /// * `project` - ID of the project that contains the read replica. /// * `instance` - Cloud SQL read replica instance name. - pub fn start_replica(&self, project: &str, instance: &str) -> InstanceStartReplicaCall<'a, C, NC, A> { + pub fn start_replica(&self, project: &str, instance: &str) -> InstanceStartReplicaCall<'a, C, A> { InstanceStartReplicaCall { hub: self.hub, _project: project.to_string(), @@ -1976,7 +1972,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `project` - Project ID of the project to which the newly created Cloud SQL instances should belong. - pub fn insert(&self, request: &DatabaseInstance, project: &str) -> InstanceInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &DatabaseInstance, project: &str) -> InstanceInsertCall<'a, C, A> { InstanceInsertCall { hub: self.hub, _request: request.clone(), @@ -1994,7 +1990,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - Project ID of the project for which to list Cloud SQL instances. - pub fn list(&self, project: &str) -> InstanceListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> InstanceListCall<'a, C, A> { InstanceListCall { hub: self.hub, _project: project.to_string(), @@ -2015,7 +2011,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Project ID of the project that contains the instance. /// * `instance` - Cloud SQL instance ID. This does not include the project ID. - pub fn import(&self, request: &InstancesImportRequest, project: &str, instance: &str) -> InstanceImportCall<'a, C, NC, A> { + pub fn import(&self, request: &InstancesImportRequest, project: &str, instance: &str) -> InstanceImportCall<'a, C, A> { InstanceImportCall { hub: self.hub, _request: request.clone(), @@ -2036,7 +2032,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Project ID of the project that contains the instance. /// * `instance` - Cloud SQL instance ID. This does not include the project ID. - pub fn update(&self, request: &DatabaseInstance, project: &str, instance: &str) -> InstanceUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &DatabaseInstance, project: &str, instance: &str) -> InstanceUpdateCall<'a, C, A> { InstanceUpdateCall { hub: self.hub, _request: request.clone(), @@ -2057,7 +2053,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Project ID of the source as well as the clone Cloud SQL instance. /// * `instance` - The ID of the Cloud SQL instance to be cloned (source). This does not include the project ID. - pub fn clone(&self, request: &InstancesCloneRequest, project: &str, instance: &str) -> InstanceCloneCall<'a, C, NC, A> { + pub fn clone(&self, request: &InstancesCloneRequest, project: &str, instance: &str) -> InstanceCloneCall<'a, C, A> { InstanceCloneCall { hub: self.hub, _request: request.clone(), @@ -2078,7 +2074,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Project ID of the project that contains the instance to be exported. /// * `instance` - Cloud SQL instance ID. This does not include the project ID. - pub fn export(&self, request: &InstancesExportRequest, project: &str, instance: &str) -> InstanceExportCall<'a, C, NC, A> { + pub fn export(&self, request: &InstancesExportRequest, project: &str, instance: &str) -> InstanceExportCall<'a, C, A> { InstanceExportCall { hub: self.hub, _request: request.clone(), @@ -2099,7 +2095,7 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Project ID of the project that contains the instance. /// * `instance` - Cloud SQL instance ID. This does not include the project ID. - pub fn restore_backup(&self, request: &InstancesRestoreBackupRequest, project: &str, instance: &str) -> InstanceRestoreBackupCall<'a, C, NC, A> { + pub fn restore_backup(&self, request: &InstancesRestoreBackupRequest, project: &str, instance: &str) -> InstanceRestoreBackupCall<'a, C, A> { InstanceRestoreBackupCall { hub: self.hub, _request: request.clone(), @@ -2142,20 +2138,20 @@ impl<'a, C, NC, A> InstanceMethods<'a, C, NC, A> { /// let rb = hub.flags(); /// # } /// ``` -pub struct FlagMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FlagMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, } -impl<'a, C, NC, A> MethodsBuilder for FlagMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for FlagMethods<'a, C, A> {} -impl<'a, C, NC, A> FlagMethods<'a, C, NC, A> { +impl<'a, C, A> FlagMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// List all available database flags for Google Cloud SQL instances. - pub fn list(&self) -> FlagListCall<'a, C, NC, A> { + pub fn list(&self) -> FlagListCall<'a, C, A> { FlagListCall { hub: self.hub, _delegate: Default::default(), @@ -2195,15 +2191,15 @@ impl<'a, C, NC, A> FlagMethods<'a, C, NC, A> { /// let rb = hub.databases(); /// # } /// ``` -pub struct DatabaseMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatabaseMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, } -impl<'a, C, NC, A> MethodsBuilder for DatabaseMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for DatabaseMethods<'a, C, A> {} -impl<'a, C, NC, A> DatabaseMethods<'a, C, NC, A> { +impl<'a, C, A> DatabaseMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2214,7 +2210,7 @@ impl<'a, C, NC, A> DatabaseMethods<'a, C, NC, A> { /// * `project` - Project ID of the project that contains the instance. /// * `instance` - Database instance ID. This does not include the project ID. /// * `database` - Name of the database to be deleted in the instance. - pub fn delete(&self, project: &str, instance: &str, database: &str) -> DatabaseDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, instance: &str, database: &str) -> DatabaseDeleteCall<'a, C, A> { DatabaseDeleteCall { hub: self.hub, _project: project.to_string(), @@ -2236,7 +2232,7 @@ impl<'a, C, NC, A> DatabaseMethods<'a, C, NC, A> { /// * `project` - Project ID of the project that contains the instance. /// * `instance` - Database instance ID. This does not include the project ID. /// * `database` - Name of the database to be updated in the instance. - pub fn patch(&self, request: &Database, project: &str, instance: &str, database: &str) -> DatabasePatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Database, project: &str, instance: &str, database: &str) -> DatabasePatchCall<'a, C, A> { DatabasePatchCall { hub: self.hub, _request: request.clone(), @@ -2257,7 +2253,7 @@ impl<'a, C, NC, A> DatabaseMethods<'a, C, NC, A> { /// /// * `project` - Project ID of the project for which to list Cloud SQL instances. /// * `instance` - Cloud SQL instance ID. This does not include the project ID. - pub fn list(&self, project: &str, instance: &str) -> DatabaseListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, instance: &str) -> DatabaseListCall<'a, C, A> { DatabaseListCall { hub: self.hub, _project: project.to_string(), @@ -2277,7 +2273,7 @@ impl<'a, C, NC, A> DatabaseMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Project ID of the project that contains the instance. /// * `instance` - Database instance ID. This does not include the project ID. - pub fn insert(&self, request: &Database, project: &str, instance: &str) -> DatabaseInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Database, project: &str, instance: &str) -> DatabaseInsertCall<'a, C, A> { DatabaseInsertCall { hub: self.hub, _request: request.clone(), @@ -2298,7 +2294,7 @@ impl<'a, C, NC, A> DatabaseMethods<'a, C, NC, A> { /// * `project` - Project ID of the project that contains the instance. /// * `instance` - Database instance ID. This does not include the project ID. /// * `database` - Name of the database in the instance. - pub fn get(&self, project: &str, instance: &str, database: &str) -> DatabaseGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, instance: &str, database: &str) -> DatabaseGetCall<'a, C, A> { DatabaseGetCall { hub: self.hub, _project: project.to_string(), @@ -2320,7 +2316,7 @@ impl<'a, C, NC, A> DatabaseMethods<'a, C, NC, A> { /// * `project` - Project ID of the project that contains the instance. /// * `instance` - Database instance ID. This does not include the project ID. /// * `database` - Name of the database to be updated in the instance. - pub fn update(&self, request: &Database, project: &str, instance: &str, database: &str) -> DatabaseUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Database, project: &str, instance: &str, database: &str) -> DatabaseUpdateCall<'a, C, A> { DatabaseUpdateCall { hub: self.hub, _request: request.clone(), @@ -2364,15 +2360,15 @@ impl<'a, C, NC, A> DatabaseMethods<'a, C, NC, A> { /// let rb = hub.ssl_certs(); /// # } /// ``` -pub struct SslCertMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SslCertMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, } -impl<'a, C, NC, A> MethodsBuilder for SslCertMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for SslCertMethods<'a, C, A> {} -impl<'a, C, NC, A> SslCertMethods<'a, C, NC, A> { +impl<'a, C, A> SslCertMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2383,7 +2379,7 @@ impl<'a, C, NC, A> SslCertMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - Project ID of the project to which the newly created Cloud SQL instances should belong. /// * `instance` - Cloud SQL instance ID. This does not include the project ID. - pub fn insert(&self, request: &SslCertsInsertRequest, project: &str, instance: &str) -> SslCertInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &SslCertsInsertRequest, project: &str, instance: &str) -> SslCertInsertCall<'a, C, A> { SslCertInsertCall { hub: self.hub, _request: request.clone(), @@ -2404,7 +2400,7 @@ impl<'a, C, NC, A> SslCertMethods<'a, C, NC, A> { /// * `project` - Project ID of the project that contains the instance to be deleted. /// * `instance` - Cloud SQL instance ID. This does not include the project ID. /// * `sha1Fingerprint` - Sha1 FingerPrint. - pub fn delete(&self, project: &str, instance: &str, sha1_fingerprint: &str) -> SslCertDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, instance: &str, sha1_fingerprint: &str) -> SslCertDeleteCall<'a, C, A> { SslCertDeleteCall { hub: self.hub, _project: project.to_string(), @@ -2425,7 +2421,7 @@ impl<'a, C, NC, A> SslCertMethods<'a, C, NC, A> { /// * `project` - Project ID of the project that contains the instance. /// * `instance` - Cloud SQL instance ID. This does not include the project ID. /// * `sha1Fingerprint` - Sha1 FingerPrint. - pub fn get(&self, project: &str, instance: &str, sha1_fingerprint: &str) -> SslCertGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, instance: &str, sha1_fingerprint: &str) -> SslCertGetCall<'a, C, A> { SslCertGetCall { hub: self.hub, _project: project.to_string(), @@ -2445,7 +2441,7 @@ impl<'a, C, NC, A> SslCertMethods<'a, C, NC, A> { /// /// * `project` - Project ID of the project for which to list Cloud SQL instances. /// * `instance` - Cloud SQL instance ID. This does not include the project ID. - pub fn list(&self, project: &str, instance: &str) -> SslCertListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, instance: &str) -> SslCertListCall<'a, C, A> { SslCertListCall { hub: self.hub, _project: project.to_string(), @@ -2487,15 +2483,15 @@ impl<'a, C, NC, A> SslCertMethods<'a, C, NC, A> { /// let rb = hub.backup_runs(); /// # } /// ``` -pub struct BackupRunMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BackupRunMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, } -impl<'a, C, NC, A> MethodsBuilder for BackupRunMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for BackupRunMethods<'a, C, A> {} -impl<'a, C, NC, A> BackupRunMethods<'a, C, NC, A> { +impl<'a, C, A> BackupRunMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -2505,7 +2501,7 @@ impl<'a, C, NC, A> BackupRunMethods<'a, C, NC, A> { /// /// * `project` - Project ID of the project that contains the instance. /// * `instance` - Cloud SQL instance ID. This does not include the project ID. - pub fn list(&self, project: &str, instance: &str) -> BackupRunListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, instance: &str) -> BackupRunListCall<'a, C, A> { BackupRunListCall { hub: self.hub, _project: project.to_string(), @@ -2527,7 +2523,7 @@ impl<'a, C, NC, A> BackupRunMethods<'a, C, NC, A> { /// * `project` - Project ID of the project that contains the instance. /// * `instance` - Cloud SQL instance ID. This does not include the project ID. /// * `id` - The ID of this Backup Run. - pub fn get(&self, project: &str, instance: &str, id: &str) -> BackupRunGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, instance: &str, id: &str) -> BackupRunGetCall<'a, C, A> { BackupRunGetCall { hub: self.hub, _project: project.to_string(), @@ -2580,10 +2576,10 @@ impl<'a, C, NC, A> BackupRunMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct OperationListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct OperationListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _project: String, _instance: String, _page_token: Option, @@ -2593,9 +2589,9 @@ pub struct OperationListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for OperationListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for OperationListCall<'a, C, A> {} -impl<'a, C, NC, A> OperationListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> OperationListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2734,7 +2730,7 @@ impl<'a, C, NC, A> OperationListCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance. - pub fn project(mut self, new_value: &str) -> OperationListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> OperationListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2744,7 +2740,7 @@ impl<'a, C, NC, A> OperationListCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Cloud SQL instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> OperationListCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> OperationListCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -2752,7 +2748,7 @@ impl<'a, C, NC, A> OperationListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// A previously-returned page token representing part of the larger set of results to view. - pub fn page_token(mut self, new_value: &str) -> OperationListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> OperationListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -2760,7 +2756,7 @@ impl<'a, C, NC, A> OperationListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Maximum number of operations per response. - pub fn max_results(mut self, new_value: u32) -> OperationListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> OperationListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -2771,7 +2767,7 @@ impl<'a, C, NC, A> OperationListCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> OperationListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> OperationListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2792,7 +2788,7 @@ impl<'a, C, NC, A> OperationListCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> OperationListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> OperationListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2809,7 +2805,7 @@ impl<'a, C, NC, A> OperationListCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> OperationListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> OperationListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2847,10 +2843,10 @@ impl<'a, C, NC, A> OperationListCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct OperationGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct OperationGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _project: String, _operation: String, _delegate: Option<&'a mut Delegate>, @@ -2858,9 +2854,9 @@ pub struct OperationGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for OperationGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for OperationGetCall<'a, C, A> {} -impl<'a, C, NC, A> OperationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> OperationGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2993,7 +2989,7 @@ impl<'a, C, NC, A> OperationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance. - pub fn project(mut self, new_value: &str) -> OperationGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> OperationGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -3003,7 +2999,7 @@ impl<'a, C, NC, A> OperationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Instance operation ID. - pub fn operation(mut self, new_value: &str) -> OperationGetCall<'a, C, NC, A> { + pub fn operation(mut self, new_value: &str) -> OperationGetCall<'a, C, A> { self._operation = new_value.to_string(); self } @@ -3014,7 +3010,7 @@ impl<'a, C, NC, A> OperationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> OperationGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> OperationGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3035,7 +3031,7 @@ impl<'a, C, NC, A> OperationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> OperationGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> OperationGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3052,7 +3048,7 @@ impl<'a, C, NC, A> OperationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> OperationGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> OperationGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3090,19 +3086,19 @@ impl<'a, C, NC, A> OperationGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct TierListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TierListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _project: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TierListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TierListCall<'a, C, A> {} -impl<'a, C, NC, A> TierListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TierListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3234,7 +3230,7 @@ impl<'a, C, NC, A> TierListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Project ID of the project for which to list tiers. - pub fn project(mut self, new_value: &str) -> TierListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TierListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -3245,7 +3241,7 @@ impl<'a, C, NC, A> TierListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TierListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TierListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3266,7 +3262,7 @@ impl<'a, C, NC, A> TierListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TierListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TierListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3283,7 +3279,7 @@ impl<'a, C, NC, A> TierListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TierListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TierListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3321,10 +3317,10 @@ impl<'a, C, NC, A> TierListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct UserListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _project: String, _instance: String, _delegate: Option<&'a mut Delegate>, @@ -3332,9 +3328,9 @@ pub struct UserListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserListCall<'a, C, A> {} -impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3467,7 +3463,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance. - pub fn project(mut self, new_value: &str) -> UserListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> UserListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -3477,7 +3473,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Database instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> UserListCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> UserListCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -3488,7 +3484,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3509,7 +3505,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3526,7 +3522,7 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3564,10 +3560,10 @@ impl<'a, C, NC, A> UserListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct UserDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _project: String, _instance: String, _host: String, @@ -3577,9 +3573,9 @@ pub struct UserDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> UserDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3714,7 +3710,7 @@ impl<'a, C, NC, A> UserDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance. - pub fn project(mut self, new_value: &str) -> UserDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> UserDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -3724,7 +3720,7 @@ impl<'a, C, NC, A> UserDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Database instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> UserDeleteCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> UserDeleteCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -3734,7 +3730,7 @@ impl<'a, C, NC, A> UserDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Host of the user in the instance. - pub fn host(mut self, new_value: &str) -> UserDeleteCall<'a, C, NC, A> { + pub fn host(mut self, new_value: &str) -> UserDeleteCall<'a, C, A> { self._host = new_value.to_string(); self } @@ -3744,7 +3740,7 @@ impl<'a, C, NC, A> UserDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Name of the user in the instance. - pub fn name(mut self, new_value: &str) -> UserDeleteCall<'a, C, NC, A> { + pub fn name(mut self, new_value: &str) -> UserDeleteCall<'a, C, A> { self._name = new_value.to_string(); self } @@ -3755,7 +3751,7 @@ impl<'a, C, NC, A> UserDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3776,7 +3772,7 @@ impl<'a, C, NC, A> UserDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3793,7 +3789,7 @@ impl<'a, C, NC, A> UserDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3837,10 +3833,10 @@ impl<'a, C, NC, A> UserDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct UserUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _request: User, _project: String, _instance: String, @@ -3851,9 +3847,9 @@ pub struct UserUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> UserUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3995,7 +3991,7 @@ impl<'a, C, NC, A> UserUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &User) -> UserUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &User) -> UserUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4005,7 +4001,7 @@ impl<'a, C, NC, A> UserUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance. - pub fn project(mut self, new_value: &str) -> UserUpdateCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> UserUpdateCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -4015,7 +4011,7 @@ impl<'a, C, NC, A> UserUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Database instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> UserUpdateCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> UserUpdateCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -4025,7 +4021,7 @@ impl<'a, C, NC, A> UserUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Host of the user in the instance. - pub fn host(mut self, new_value: &str) -> UserUpdateCall<'a, C, NC, A> { + pub fn host(mut self, new_value: &str) -> UserUpdateCall<'a, C, A> { self._host = new_value.to_string(); self } @@ -4035,7 +4031,7 @@ impl<'a, C, NC, A> UserUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Name of the user in the instance. - pub fn name(mut self, new_value: &str) -> UserUpdateCall<'a, C, NC, A> { + pub fn name(mut self, new_value: &str) -> UserUpdateCall<'a, C, A> { self._name = new_value.to_string(); self } @@ -4046,7 +4042,7 @@ impl<'a, C, NC, A> UserUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4067,7 +4063,7 @@ impl<'a, C, NC, A> UserUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4084,7 +4080,7 @@ impl<'a, C, NC, A> UserUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4128,10 +4124,10 @@ impl<'a, C, NC, A> UserUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct UserInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UserInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _request: User, _project: String, _instance: String, @@ -4140,9 +4136,9 @@ pub struct UserInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UserInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UserInsertCall<'a, C, A> {} -impl<'a, C, NC, A> UserInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UserInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4282,7 +4278,7 @@ impl<'a, C, NC, A> UserInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &User) -> UserInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &User) -> UserInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4292,7 +4288,7 @@ impl<'a, C, NC, A> UserInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance. - pub fn project(mut self, new_value: &str) -> UserInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> UserInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -4302,7 +4298,7 @@ impl<'a, C, NC, A> UserInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Database instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> UserInsertCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> UserInsertCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -4313,7 +4309,7 @@ impl<'a, C, NC, A> UserInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UserInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4334,7 +4330,7 @@ impl<'a, C, NC, A> UserInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UserInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UserInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4351,7 +4347,7 @@ impl<'a, C, NC, A> UserInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UserInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UserInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4389,10 +4385,10 @@ impl<'a, C, NC, A> UserInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct InstanceResetSslConfigCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceResetSslConfigCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _project: String, _instance: String, _delegate: Option<&'a mut Delegate>, @@ -4400,9 +4396,9 @@ pub struct InstanceResetSslConfigCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceResetSslConfigCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceResetSslConfigCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceResetSslConfigCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceResetSslConfigCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4535,7 +4531,7 @@ impl<'a, C, NC, A> InstanceResetSslConfigCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance. - pub fn project(mut self, new_value: &str) -> InstanceResetSslConfigCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceResetSslConfigCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -4545,7 +4541,7 @@ impl<'a, C, NC, A> InstanceResetSslConfigCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Cloud SQL instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> InstanceResetSslConfigCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceResetSslConfigCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -4556,7 +4552,7 @@ impl<'a, C, NC, A> InstanceResetSslConfigCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceResetSslConfigCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceResetSslConfigCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4577,7 +4573,7 @@ impl<'a, C, NC, A> InstanceResetSslConfigCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceResetSslConfigCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceResetSslConfigCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4594,7 +4590,7 @@ impl<'a, C, NC, A> InstanceResetSslConfigCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceResetSslConfigCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceResetSslConfigCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4632,10 +4628,10 @@ impl<'a, C, NC, A> InstanceResetSslConfigCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct InstancePromoteReplicaCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstancePromoteReplicaCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _project: String, _instance: String, _delegate: Option<&'a mut Delegate>, @@ -4643,9 +4639,9 @@ pub struct InstancePromoteReplicaCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstancePromoteReplicaCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstancePromoteReplicaCall<'a, C, A> {} -impl<'a, C, NC, A> InstancePromoteReplicaCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstancePromoteReplicaCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4778,7 +4774,7 @@ impl<'a, C, NC, A> InstancePromoteReplicaCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// ID of the project that contains the read replica. - pub fn project(mut self, new_value: &str) -> InstancePromoteReplicaCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstancePromoteReplicaCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -4788,7 +4784,7 @@ impl<'a, C, NC, A> InstancePromoteReplicaCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Cloud SQL read replica instance name. - pub fn instance(mut self, new_value: &str) -> InstancePromoteReplicaCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstancePromoteReplicaCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -4799,7 +4795,7 @@ impl<'a, C, NC, A> InstancePromoteReplicaCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstancePromoteReplicaCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstancePromoteReplicaCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4820,7 +4816,7 @@ impl<'a, C, NC, A> InstancePromoteReplicaCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstancePromoteReplicaCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstancePromoteReplicaCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4837,7 +4833,7 @@ impl<'a, C, NC, A> InstancePromoteReplicaCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstancePromoteReplicaCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstancePromoteReplicaCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4875,10 +4871,10 @@ impl<'a, C, NC, A> InstancePromoteReplicaCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct InstanceGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _project: String, _instance: String, _delegate: Option<&'a mut Delegate>, @@ -4886,9 +4882,9 @@ pub struct InstanceGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceGetCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5021,7 +5017,7 @@ impl<'a, C, NC, A> InstanceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance. - pub fn project(mut self, new_value: &str) -> InstanceGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -5031,7 +5027,7 @@ impl<'a, C, NC, A> InstanceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Database instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> InstanceGetCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceGetCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -5042,7 +5038,7 @@ impl<'a, C, NC, A> InstanceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5063,7 +5059,7 @@ impl<'a, C, NC, A> InstanceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5080,7 +5076,7 @@ impl<'a, C, NC, A> InstanceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5124,10 +5120,10 @@ impl<'a, C, NC, A> InstanceGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct InstancePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstancePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _request: DatabaseInstance, _project: String, _instance: String, @@ -5136,9 +5132,9 @@ pub struct InstancePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstancePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstancePatchCall<'a, C, A> {} -impl<'a, C, NC, A> InstancePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstancePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5278,7 +5274,7 @@ impl<'a, C, NC, A> InstancePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &DatabaseInstance) -> InstancePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &DatabaseInstance) -> InstancePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5288,7 +5284,7 @@ impl<'a, C, NC, A> InstancePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance. - pub fn project(mut self, new_value: &str) -> InstancePatchCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstancePatchCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -5298,7 +5294,7 @@ impl<'a, C, NC, A> InstancePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Cloud SQL instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> InstancePatchCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstancePatchCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -5309,7 +5305,7 @@ impl<'a, C, NC, A> InstancePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstancePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstancePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5330,7 +5326,7 @@ impl<'a, C, NC, A> InstancePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstancePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstancePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5347,7 +5343,7 @@ impl<'a, C, NC, A> InstancePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstancePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstancePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5385,10 +5381,10 @@ impl<'a, C, NC, A> InstancePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct InstanceRestartCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceRestartCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _project: String, _instance: String, _delegate: Option<&'a mut Delegate>, @@ -5396,9 +5392,9 @@ pub struct InstanceRestartCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceRestartCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceRestartCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceRestartCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceRestartCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5531,7 +5527,7 @@ impl<'a, C, NC, A> InstanceRestartCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance to be restarted. - pub fn project(mut self, new_value: &str) -> InstanceRestartCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceRestartCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -5541,7 +5537,7 @@ impl<'a, C, NC, A> InstanceRestartCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// Cloud SQL instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> InstanceRestartCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceRestartCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -5552,7 +5548,7 @@ impl<'a, C, NC, A> InstanceRestartCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceRestartCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceRestartCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5573,7 +5569,7 @@ impl<'a, C, NC, A> InstanceRestartCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceRestartCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceRestartCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5590,7 +5586,7 @@ impl<'a, C, NC, A> InstanceRestartCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceRestartCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceRestartCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5628,10 +5624,10 @@ impl<'a, C, NC, A> InstanceRestartCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct InstanceDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _project: String, _instance: String, _delegate: Option<&'a mut Delegate>, @@ -5639,9 +5635,9 @@ pub struct InstanceDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5774,7 +5770,7 @@ impl<'a, C, NC, A> InstanceDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance to be deleted. - pub fn project(mut self, new_value: &str) -> InstanceDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -5784,7 +5780,7 @@ impl<'a, C, NC, A> InstanceDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Cloud SQL instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> InstanceDeleteCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceDeleteCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -5795,7 +5791,7 @@ impl<'a, C, NC, A> InstanceDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5816,7 +5812,7 @@ impl<'a, C, NC, A> InstanceDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5833,7 +5829,7 @@ impl<'a, C, NC, A> InstanceDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5871,10 +5867,10 @@ impl<'a, C, NC, A> InstanceDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct InstanceStopReplicaCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceStopReplicaCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _project: String, _instance: String, _delegate: Option<&'a mut Delegate>, @@ -5882,9 +5878,9 @@ pub struct InstanceStopReplicaCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceStopReplicaCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceStopReplicaCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceStopReplicaCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceStopReplicaCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6017,7 +6013,7 @@ impl<'a, C, NC, A> InstanceStopReplicaCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// ID of the project that contains the read replica. - pub fn project(mut self, new_value: &str) -> InstanceStopReplicaCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceStopReplicaCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -6027,7 +6023,7 @@ impl<'a, C, NC, A> InstanceStopReplicaCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// Cloud SQL read replica instance name. - pub fn instance(mut self, new_value: &str) -> InstanceStopReplicaCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceStopReplicaCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -6038,7 +6034,7 @@ impl<'a, C, NC, A> InstanceStopReplicaCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceStopReplicaCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceStopReplicaCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6059,7 +6055,7 @@ impl<'a, C, NC, A> InstanceStopReplicaCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceStopReplicaCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceStopReplicaCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6076,7 +6072,7 @@ impl<'a, C, NC, A> InstanceStopReplicaCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceStopReplicaCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceStopReplicaCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6114,10 +6110,10 @@ impl<'a, C, NC, A> InstanceStopReplicaCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct InstanceStartReplicaCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceStartReplicaCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _project: String, _instance: String, _delegate: Option<&'a mut Delegate>, @@ -6125,9 +6121,9 @@ pub struct InstanceStartReplicaCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceStartReplicaCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceStartReplicaCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceStartReplicaCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceStartReplicaCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6260,7 +6256,7 @@ impl<'a, C, NC, A> InstanceStartReplicaCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// ID of the project that contains the read replica. - pub fn project(mut self, new_value: &str) -> InstanceStartReplicaCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceStartReplicaCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -6270,7 +6266,7 @@ impl<'a, C, NC, A> InstanceStartReplicaCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// Cloud SQL read replica instance name. - pub fn instance(mut self, new_value: &str) -> InstanceStartReplicaCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceStartReplicaCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -6281,7 +6277,7 @@ impl<'a, C, NC, A> InstanceStartReplicaCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceStartReplicaCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceStartReplicaCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6302,7 +6298,7 @@ impl<'a, C, NC, A> InstanceStartReplicaCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceStartReplicaCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceStartReplicaCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6319,7 +6315,7 @@ impl<'a, C, NC, A> InstanceStartReplicaCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceStartReplicaCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceStartReplicaCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6363,10 +6359,10 @@ impl<'a, C, NC, A> InstanceStartReplicaCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct InstanceInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _request: DatabaseInstance, _project: String, _delegate: Option<&'a mut Delegate>, @@ -6374,9 +6370,9 @@ pub struct InstanceInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceInsertCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6515,7 +6511,7 @@ impl<'a, C, NC, A> InstanceInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &DatabaseInstance) -> InstanceInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &DatabaseInstance) -> InstanceInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6525,7 +6521,7 @@ impl<'a, C, NC, A> InstanceInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Project ID of the project to which the newly created Cloud SQL instances should belong. - pub fn project(mut self, new_value: &str) -> InstanceInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -6536,7 +6532,7 @@ impl<'a, C, NC, A> InstanceInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6557,7 +6553,7 @@ impl<'a, C, NC, A> InstanceInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6574,7 +6570,7 @@ impl<'a, C, NC, A> InstanceInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6614,10 +6610,10 @@ impl<'a, C, NC, A> InstanceInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct InstanceListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _project: String, _page_token: Option, _max_results: Option, @@ -6626,9 +6622,9 @@ pub struct InstanceListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceListCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6766,7 +6762,7 @@ impl<'a, C, NC, A> InstanceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Project ID of the project for which to list Cloud SQL instances. - pub fn project(mut self, new_value: &str) -> InstanceListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -6774,7 +6770,7 @@ impl<'a, C, NC, A> InstanceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// A previously-returned page token representing part of the larger set of results to view. - pub fn page_token(mut self, new_value: &str) -> InstanceListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> InstanceListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -6782,7 +6778,7 @@ impl<'a, C, NC, A> InstanceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The maximum number of results to return per response. - pub fn max_results(mut self, new_value: u32) -> InstanceListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> InstanceListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -6793,7 +6789,7 @@ impl<'a, C, NC, A> InstanceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6814,7 +6810,7 @@ impl<'a, C, NC, A> InstanceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6831,7 +6827,7 @@ impl<'a, C, NC, A> InstanceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6875,10 +6871,10 @@ impl<'a, C, NC, A> InstanceListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct InstanceImportCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceImportCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _request: InstancesImportRequest, _project: String, _instance: String, @@ -6887,9 +6883,9 @@ pub struct InstanceImportCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceImportCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceImportCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceImportCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceImportCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7029,7 +7025,7 @@ impl<'a, C, NC, A> InstanceImportCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &InstancesImportRequest) -> InstanceImportCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &InstancesImportRequest) -> InstanceImportCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7039,7 +7035,7 @@ impl<'a, C, NC, A> InstanceImportCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance. - pub fn project(mut self, new_value: &str) -> InstanceImportCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceImportCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -7049,7 +7045,7 @@ impl<'a, C, NC, A> InstanceImportCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Cloud SQL instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> InstanceImportCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceImportCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -7060,7 +7056,7 @@ impl<'a, C, NC, A> InstanceImportCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceImportCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceImportCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7081,7 +7077,7 @@ impl<'a, C, NC, A> InstanceImportCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceImportCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceImportCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7098,7 +7094,7 @@ impl<'a, C, NC, A> InstanceImportCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceImportCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceImportCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7142,10 +7138,10 @@ impl<'a, C, NC, A> InstanceImportCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct InstanceUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _request: DatabaseInstance, _project: String, _instance: String, @@ -7154,9 +7150,9 @@ pub struct InstanceUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7296,7 +7292,7 @@ impl<'a, C, NC, A> InstanceUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &DatabaseInstance) -> InstanceUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &DatabaseInstance) -> InstanceUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7306,7 +7302,7 @@ impl<'a, C, NC, A> InstanceUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance. - pub fn project(mut self, new_value: &str) -> InstanceUpdateCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceUpdateCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -7316,7 +7312,7 @@ impl<'a, C, NC, A> InstanceUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Cloud SQL instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> InstanceUpdateCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceUpdateCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -7327,7 +7323,7 @@ impl<'a, C, NC, A> InstanceUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7348,7 +7344,7 @@ impl<'a, C, NC, A> InstanceUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7365,7 +7361,7 @@ impl<'a, C, NC, A> InstanceUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7409,10 +7405,10 @@ impl<'a, C, NC, A> InstanceUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct InstanceCloneCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceCloneCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _request: InstancesCloneRequest, _project: String, _instance: String, @@ -7421,9 +7417,9 @@ pub struct InstanceCloneCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceCloneCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceCloneCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceCloneCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceCloneCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7563,7 +7559,7 @@ impl<'a, C, NC, A> InstanceCloneCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &InstancesCloneRequest) -> InstanceCloneCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &InstancesCloneRequest) -> InstanceCloneCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7573,7 +7569,7 @@ impl<'a, C, NC, A> InstanceCloneCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Project ID of the source as well as the clone Cloud SQL instance. - pub fn project(mut self, new_value: &str) -> InstanceCloneCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceCloneCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -7583,7 +7579,7 @@ impl<'a, C, NC, A> InstanceCloneCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The ID of the Cloud SQL instance to be cloned (source). This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> InstanceCloneCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceCloneCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -7594,7 +7590,7 @@ impl<'a, C, NC, A> InstanceCloneCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceCloneCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceCloneCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7615,7 +7611,7 @@ impl<'a, C, NC, A> InstanceCloneCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceCloneCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceCloneCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7632,7 +7628,7 @@ impl<'a, C, NC, A> InstanceCloneCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceCloneCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceCloneCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7676,10 +7672,10 @@ impl<'a, C, NC, A> InstanceCloneCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct InstanceExportCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceExportCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _request: InstancesExportRequest, _project: String, _instance: String, @@ -7688,9 +7684,9 @@ pub struct InstanceExportCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceExportCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceExportCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceExportCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceExportCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7830,7 +7826,7 @@ impl<'a, C, NC, A> InstanceExportCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &InstancesExportRequest) -> InstanceExportCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &InstancesExportRequest) -> InstanceExportCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7840,7 +7836,7 @@ impl<'a, C, NC, A> InstanceExportCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance to be exported. - pub fn project(mut self, new_value: &str) -> InstanceExportCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceExportCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -7850,7 +7846,7 @@ impl<'a, C, NC, A> InstanceExportCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Cloud SQL instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> InstanceExportCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceExportCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -7861,7 +7857,7 @@ impl<'a, C, NC, A> InstanceExportCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceExportCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceExportCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7882,7 +7878,7 @@ impl<'a, C, NC, A> InstanceExportCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceExportCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceExportCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7899,7 +7895,7 @@ impl<'a, C, NC, A> InstanceExportCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceExportCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceExportCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7943,10 +7939,10 @@ impl<'a, C, NC, A> InstanceExportCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct InstanceRestoreBackupCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct InstanceRestoreBackupCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _request: InstancesRestoreBackupRequest, _project: String, _instance: String, @@ -7955,9 +7951,9 @@ pub struct InstanceRestoreBackupCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for InstanceRestoreBackupCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for InstanceRestoreBackupCall<'a, C, A> {} -impl<'a, C, NC, A> InstanceRestoreBackupCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> InstanceRestoreBackupCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8097,7 +8093,7 @@ impl<'a, C, NC, A> InstanceRestoreBackupCall<'a, C, NC, A> where NC: hyper::net: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &InstancesRestoreBackupRequest) -> InstanceRestoreBackupCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &InstancesRestoreBackupRequest) -> InstanceRestoreBackupCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8107,7 +8103,7 @@ impl<'a, C, NC, A> InstanceRestoreBackupCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance. - pub fn project(mut self, new_value: &str) -> InstanceRestoreBackupCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> InstanceRestoreBackupCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -8117,7 +8113,7 @@ impl<'a, C, NC, A> InstanceRestoreBackupCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// Cloud SQL instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> InstanceRestoreBackupCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> InstanceRestoreBackupCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -8128,7 +8124,7 @@ impl<'a, C, NC, A> InstanceRestoreBackupCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceRestoreBackupCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> InstanceRestoreBackupCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8149,7 +8145,7 @@ impl<'a, C, NC, A> InstanceRestoreBackupCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> InstanceRestoreBackupCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> InstanceRestoreBackupCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8166,7 +8162,7 @@ impl<'a, C, NC, A> InstanceRestoreBackupCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> InstanceRestoreBackupCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> InstanceRestoreBackupCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8204,18 +8200,18 @@ impl<'a, C, NC, A> InstanceRestoreBackupCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct FlagListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct FlagListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for FlagListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for FlagListCall<'a, C, A> {} -impl<'a, C, NC, A> FlagListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> FlagListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8323,7 +8319,7 @@ impl<'a, C, NC, A> FlagListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> FlagListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> FlagListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8344,7 +8340,7 @@ impl<'a, C, NC, A> FlagListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> FlagListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> FlagListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8361,7 +8357,7 @@ impl<'a, C, NC, A> FlagListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> FlagListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> FlagListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8399,10 +8395,10 @@ impl<'a, C, NC, A> FlagListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct DatabaseDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatabaseDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _project: String, _instance: String, _database: String, @@ -8411,9 +8407,9 @@ pub struct DatabaseDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatabaseDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatabaseDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> DatabaseDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatabaseDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8547,7 +8543,7 @@ impl<'a, C, NC, A> DatabaseDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance. - pub fn project(mut self, new_value: &str) -> DatabaseDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> DatabaseDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -8557,7 +8553,7 @@ impl<'a, C, NC, A> DatabaseDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Database instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> DatabaseDeleteCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> DatabaseDeleteCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -8567,7 +8563,7 @@ impl<'a, C, NC, A> DatabaseDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Name of the database to be deleted in the instance. - pub fn database(mut self, new_value: &str) -> DatabaseDeleteCall<'a, C, NC, A> { + pub fn database(mut self, new_value: &str) -> DatabaseDeleteCall<'a, C, A> { self._database = new_value.to_string(); self } @@ -8578,7 +8574,7 @@ impl<'a, C, NC, A> DatabaseDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatabaseDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatabaseDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8599,7 +8595,7 @@ impl<'a, C, NC, A> DatabaseDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatabaseDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatabaseDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8616,7 +8612,7 @@ impl<'a, C, NC, A> DatabaseDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatabaseDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatabaseDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8660,10 +8656,10 @@ impl<'a, C, NC, A> DatabaseDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct DatabasePatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatabasePatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _request: Database, _project: String, _instance: String, @@ -8673,9 +8669,9 @@ pub struct DatabasePatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatabasePatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatabasePatchCall<'a, C, A> {} -impl<'a, C, NC, A> DatabasePatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatabasePatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8816,7 +8812,7 @@ impl<'a, C, NC, A> DatabasePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Database) -> DatabasePatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Database) -> DatabasePatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8826,7 +8822,7 @@ impl<'a, C, NC, A> DatabasePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance. - pub fn project(mut self, new_value: &str) -> DatabasePatchCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> DatabasePatchCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -8836,7 +8832,7 @@ impl<'a, C, NC, A> DatabasePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Database instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> DatabasePatchCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> DatabasePatchCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -8846,7 +8842,7 @@ impl<'a, C, NC, A> DatabasePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Name of the database to be updated in the instance. - pub fn database(mut self, new_value: &str) -> DatabasePatchCall<'a, C, NC, A> { + pub fn database(mut self, new_value: &str) -> DatabasePatchCall<'a, C, A> { self._database = new_value.to_string(); self } @@ -8857,7 +8853,7 @@ impl<'a, C, NC, A> DatabasePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatabasePatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatabasePatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8878,7 +8874,7 @@ impl<'a, C, NC, A> DatabasePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatabasePatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatabasePatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8895,7 +8891,7 @@ impl<'a, C, NC, A> DatabasePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatabasePatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatabasePatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8933,10 +8929,10 @@ impl<'a, C, NC, A> DatabasePatchCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct DatabaseListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatabaseListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _project: String, _instance: String, _delegate: Option<&'a mut Delegate>, @@ -8944,9 +8940,9 @@ pub struct DatabaseListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatabaseListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatabaseListCall<'a, C, A> {} -impl<'a, C, NC, A> DatabaseListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatabaseListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9079,7 +9075,7 @@ impl<'a, C, NC, A> DatabaseListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Project ID of the project for which to list Cloud SQL instances. - pub fn project(mut self, new_value: &str) -> DatabaseListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> DatabaseListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -9089,7 +9085,7 @@ impl<'a, C, NC, A> DatabaseListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Cloud SQL instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> DatabaseListCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> DatabaseListCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -9100,7 +9096,7 @@ impl<'a, C, NC, A> DatabaseListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatabaseListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatabaseListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9121,7 +9117,7 @@ impl<'a, C, NC, A> DatabaseListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatabaseListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatabaseListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9138,7 +9134,7 @@ impl<'a, C, NC, A> DatabaseListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatabaseListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatabaseListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9182,10 +9178,10 @@ impl<'a, C, NC, A> DatabaseListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct DatabaseInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatabaseInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _request: Database, _project: String, _instance: String, @@ -9194,9 +9190,9 @@ pub struct DatabaseInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatabaseInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatabaseInsertCall<'a, C, A> {} -impl<'a, C, NC, A> DatabaseInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatabaseInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9336,7 +9332,7 @@ impl<'a, C, NC, A> DatabaseInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Database) -> DatabaseInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Database) -> DatabaseInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9346,7 +9342,7 @@ impl<'a, C, NC, A> DatabaseInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance. - pub fn project(mut self, new_value: &str) -> DatabaseInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> DatabaseInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -9356,7 +9352,7 @@ impl<'a, C, NC, A> DatabaseInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Database instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> DatabaseInsertCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> DatabaseInsertCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -9367,7 +9363,7 @@ impl<'a, C, NC, A> DatabaseInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatabaseInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatabaseInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9388,7 +9384,7 @@ impl<'a, C, NC, A> DatabaseInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatabaseInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatabaseInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9405,7 +9401,7 @@ impl<'a, C, NC, A> DatabaseInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatabaseInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatabaseInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9443,10 +9439,10 @@ impl<'a, C, NC, A> DatabaseInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct DatabaseGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatabaseGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _project: String, _instance: String, _database: String, @@ -9455,9 +9451,9 @@ pub struct DatabaseGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatabaseGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatabaseGetCall<'a, C, A> {} -impl<'a, C, NC, A> DatabaseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatabaseGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9591,7 +9587,7 @@ impl<'a, C, NC, A> DatabaseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance. - pub fn project(mut self, new_value: &str) -> DatabaseGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> DatabaseGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -9601,7 +9597,7 @@ impl<'a, C, NC, A> DatabaseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Database instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> DatabaseGetCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> DatabaseGetCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -9611,7 +9607,7 @@ impl<'a, C, NC, A> DatabaseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Name of the database in the instance. - pub fn database(mut self, new_value: &str) -> DatabaseGetCall<'a, C, NC, A> { + pub fn database(mut self, new_value: &str) -> DatabaseGetCall<'a, C, A> { self._database = new_value.to_string(); self } @@ -9622,7 +9618,7 @@ impl<'a, C, NC, A> DatabaseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatabaseGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatabaseGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9643,7 +9639,7 @@ impl<'a, C, NC, A> DatabaseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatabaseGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatabaseGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9660,7 +9656,7 @@ impl<'a, C, NC, A> DatabaseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatabaseGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatabaseGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9704,10 +9700,10 @@ impl<'a, C, NC, A> DatabaseGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct DatabaseUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DatabaseUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _request: Database, _project: String, _instance: String, @@ -9717,9 +9713,9 @@ pub struct DatabaseUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DatabaseUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DatabaseUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> DatabaseUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DatabaseUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9860,7 +9856,7 @@ impl<'a, C, NC, A> DatabaseUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Database) -> DatabaseUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Database) -> DatabaseUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9870,7 +9866,7 @@ impl<'a, C, NC, A> DatabaseUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance. - pub fn project(mut self, new_value: &str) -> DatabaseUpdateCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> DatabaseUpdateCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -9880,7 +9876,7 @@ impl<'a, C, NC, A> DatabaseUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Database instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> DatabaseUpdateCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> DatabaseUpdateCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -9890,7 +9886,7 @@ impl<'a, C, NC, A> DatabaseUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Name of the database to be updated in the instance. - pub fn database(mut self, new_value: &str) -> DatabaseUpdateCall<'a, C, NC, A> { + pub fn database(mut self, new_value: &str) -> DatabaseUpdateCall<'a, C, A> { self._database = new_value.to_string(); self } @@ -9901,7 +9897,7 @@ impl<'a, C, NC, A> DatabaseUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatabaseUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DatabaseUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9922,7 +9918,7 @@ impl<'a, C, NC, A> DatabaseUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DatabaseUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DatabaseUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9939,7 +9935,7 @@ impl<'a, C, NC, A> DatabaseUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DatabaseUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DatabaseUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9983,10 +9979,10 @@ impl<'a, C, NC, A> DatabaseUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct SslCertInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SslCertInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _request: SslCertsInsertRequest, _project: String, _instance: String, @@ -9995,9 +9991,9 @@ pub struct SslCertInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SslCertInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SslCertInsertCall<'a, C, A> {} -impl<'a, C, NC, A> SslCertInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SslCertInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10137,7 +10133,7 @@ impl<'a, C, NC, A> SslCertInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &SslCertsInsertRequest) -> SslCertInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &SslCertsInsertRequest) -> SslCertInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -10147,7 +10143,7 @@ impl<'a, C, NC, A> SslCertInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Project ID of the project to which the newly created Cloud SQL instances should belong. - pub fn project(mut self, new_value: &str) -> SslCertInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> SslCertInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -10157,7 +10153,7 @@ impl<'a, C, NC, A> SslCertInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Cloud SQL instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> SslCertInsertCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> SslCertInsertCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -10168,7 +10164,7 @@ impl<'a, C, NC, A> SslCertInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SslCertInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SslCertInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10189,7 +10185,7 @@ impl<'a, C, NC, A> SslCertInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SslCertInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SslCertInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10206,7 +10202,7 @@ impl<'a, C, NC, A> SslCertInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SslCertInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SslCertInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10244,10 +10240,10 @@ impl<'a, C, NC, A> SslCertInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct SslCertDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SslCertDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _project: String, _instance: String, _sha1_fingerprint: String, @@ -10256,9 +10252,9 @@ pub struct SslCertDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SslCertDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SslCertDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> SslCertDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SslCertDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10392,7 +10388,7 @@ impl<'a, C, NC, A> SslCertDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance to be deleted. - pub fn project(mut self, new_value: &str) -> SslCertDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> SslCertDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -10402,7 +10398,7 @@ impl<'a, C, NC, A> SslCertDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Cloud SQL instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> SslCertDeleteCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> SslCertDeleteCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -10412,7 +10408,7 @@ impl<'a, C, NC, A> SslCertDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Sha1 FingerPrint. - pub fn sha1_fingerprint(mut self, new_value: &str) -> SslCertDeleteCall<'a, C, NC, A> { + pub fn sha1_fingerprint(mut self, new_value: &str) -> SslCertDeleteCall<'a, C, A> { self._sha1_fingerprint = new_value.to_string(); self } @@ -10423,7 +10419,7 @@ impl<'a, C, NC, A> SslCertDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SslCertDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SslCertDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10444,7 +10440,7 @@ impl<'a, C, NC, A> SslCertDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SslCertDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SslCertDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10461,7 +10457,7 @@ impl<'a, C, NC, A> SslCertDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SslCertDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SslCertDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10499,10 +10495,10 @@ impl<'a, C, NC, A> SslCertDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct SslCertGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SslCertGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _project: String, _instance: String, _sha1_fingerprint: String, @@ -10511,9 +10507,9 @@ pub struct SslCertGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SslCertGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SslCertGetCall<'a, C, A> {} -impl<'a, C, NC, A> SslCertGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SslCertGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10647,7 +10643,7 @@ impl<'a, C, NC, A> SslCertGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance. - pub fn project(mut self, new_value: &str) -> SslCertGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> SslCertGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -10657,7 +10653,7 @@ impl<'a, C, NC, A> SslCertGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Cloud SQL instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> SslCertGetCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> SslCertGetCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -10667,7 +10663,7 @@ impl<'a, C, NC, A> SslCertGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Sha1 FingerPrint. - pub fn sha1_fingerprint(mut self, new_value: &str) -> SslCertGetCall<'a, C, NC, A> { + pub fn sha1_fingerprint(mut self, new_value: &str) -> SslCertGetCall<'a, C, A> { self._sha1_fingerprint = new_value.to_string(); self } @@ -10678,7 +10674,7 @@ impl<'a, C, NC, A> SslCertGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SslCertGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SslCertGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10699,7 +10695,7 @@ impl<'a, C, NC, A> SslCertGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SslCertGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SslCertGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10716,7 +10712,7 @@ impl<'a, C, NC, A> SslCertGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SslCertGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SslCertGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10754,10 +10750,10 @@ impl<'a, C, NC, A> SslCertGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct SslCertListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SslCertListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _project: String, _instance: String, _delegate: Option<&'a mut Delegate>, @@ -10765,9 +10761,9 @@ pub struct SslCertListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SslCertListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SslCertListCall<'a, C, A> {} -impl<'a, C, NC, A> SslCertListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SslCertListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10900,7 +10896,7 @@ impl<'a, C, NC, A> SslCertListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Project ID of the project for which to list Cloud SQL instances. - pub fn project(mut self, new_value: &str) -> SslCertListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> SslCertListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -10910,7 +10906,7 @@ impl<'a, C, NC, A> SslCertListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Cloud SQL instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> SslCertListCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> SslCertListCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -10921,7 +10917,7 @@ impl<'a, C, NC, A> SslCertListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SslCertListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SslCertListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10942,7 +10938,7 @@ impl<'a, C, NC, A> SslCertListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SslCertListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SslCertListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10959,7 +10955,7 @@ impl<'a, C, NC, A> SslCertListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SslCertListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SslCertListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10999,10 +10995,10 @@ impl<'a, C, NC, A> SslCertListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct BackupRunListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BackupRunListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _project: String, _instance: String, _page_token: Option, @@ -11012,9 +11008,9 @@ pub struct BackupRunListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BackupRunListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BackupRunListCall<'a, C, A> {} -impl<'a, C, NC, A> BackupRunListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BackupRunListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11153,7 +11149,7 @@ impl<'a, C, NC, A> BackupRunListCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance. - pub fn project(mut self, new_value: &str) -> BackupRunListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> BackupRunListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -11163,7 +11159,7 @@ impl<'a, C, NC, A> BackupRunListCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Cloud SQL instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> BackupRunListCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> BackupRunListCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -11171,7 +11167,7 @@ impl<'a, C, NC, A> BackupRunListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// A previously-returned page token representing part of the larger set of results to view. - pub fn page_token(mut self, new_value: &str) -> BackupRunListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> BackupRunListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -11179,7 +11175,7 @@ impl<'a, C, NC, A> BackupRunListCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Maximum number of backup runs per response. - pub fn max_results(mut self, new_value: i32) -> BackupRunListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> BackupRunListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -11190,7 +11186,7 @@ impl<'a, C, NC, A> BackupRunListCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BackupRunListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BackupRunListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11211,7 +11207,7 @@ impl<'a, C, NC, A> BackupRunListCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BackupRunListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BackupRunListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11228,7 +11224,7 @@ impl<'a, C, NC, A> BackupRunListCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BackupRunListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BackupRunListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11266,10 +11262,10 @@ impl<'a, C, NC, A> BackupRunListCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct BackupRunGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BackupRunGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a SQLAdmin, + hub: &'a SQLAdmin, _project: String, _instance: String, _id: String, @@ -11278,9 +11274,9 @@ pub struct BackupRunGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BackupRunGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BackupRunGetCall<'a, C, A> {} -impl<'a, C, NC, A> BackupRunGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BackupRunGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11414,7 +11410,7 @@ impl<'a, C, NC, A> BackupRunGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Project ID of the project that contains the instance. - pub fn project(mut self, new_value: &str) -> BackupRunGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> BackupRunGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -11424,7 +11420,7 @@ impl<'a, C, NC, A> BackupRunGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Cloud SQL instance ID. This does not include the project ID. - pub fn instance(mut self, new_value: &str) -> BackupRunGetCall<'a, C, NC, A> { + pub fn instance(mut self, new_value: &str) -> BackupRunGetCall<'a, C, A> { self._instance = new_value.to_string(); self } @@ -11434,7 +11430,7 @@ impl<'a, C, NC, A> BackupRunGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The ID of this Backup Run. - pub fn id(mut self, new_value: &str) -> BackupRunGetCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> BackupRunGetCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -11445,7 +11441,7 @@ impl<'a, C, NC, A> BackupRunGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BackupRunGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BackupRunGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11466,7 +11462,7 @@ impl<'a, C, NC, A> BackupRunGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BackupRunGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BackupRunGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11483,7 +11479,7 @@ impl<'a, C, NC, A> BackupRunGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BackupRunGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BackupRunGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/storage1/Cargo.toml b/gen/storage1/Cargo.toml index b1b293ddd70..e75bb479663 100644 --- a/gen/storage1/Cargo.toml +++ b/gen/storage1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-storage1" -version = "0.1.4+20150326" +version = "0.1.5+20150326" authors = ["Sebastian Thiel "] description = "A complete library to interact with storage (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/storage1" homepage = "https://developers.google.com/storage/docs/json_api/" -documentation = "http://byron.github.io/google-apis-rs/google-storage1" +documentation = "http://byron.github.io/google-apis-rs/google_storage1" license = "MIT" keywords = ["storage", "google", "protocol", "web", "api"] diff --git a/gen/storage1/README.md b/gen/storage1/README.md index 11f15799274..12ab36177f6 100644 --- a/gen/storage1/README.md +++ b/gen/storage1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-storage1` library allows access to all features of the *Google storage* service. -This documentation was generated from *storage* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *storage:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *storage* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *storage:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *storage* *v1* API can be found at the [official documentation site](https://developers.google.com/storage/docs/json_api/). diff --git a/gen/storage1/src/cmn.rs b/gen/storage1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/storage1/src/cmn.rs +++ b/gen/storage1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/storage1/src/lib.rs b/gen/storage1/src/lib.rs index 94ea23b5a7d..41a9d8160ef 100644 --- a/gen/storage1/src/lib.rs +++ b/gen/storage1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *storage* crate version *0.1.4+20150326*, where *20150326* is the exact revision of the *storage:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *storage* crate version *0.1.5+20150326*, where *20150326* is the exact revision of the *storage:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *storage* *v1* API can be found at the //! [official documentation site](https://developers.google.com/storage/docs/json_api/). @@ -231,7 +231,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -341,49 +340,46 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Storage { +pub struct Storage { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Storage {} +impl<'a, C, A> Hub for Storage {} -impl<'a, C, NC, A> Storage - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Storage + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Storage { + pub fn new(client: C, authenticator: A) -> Storage { Storage { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn bucket_access_controls(&'a self) -> BucketAccessControlMethods<'a, C, NC, A> { + pub fn bucket_access_controls(&'a self) -> BucketAccessControlMethods<'a, C, A> { BucketAccessControlMethods { hub: &self } } - pub fn buckets(&'a self) -> BucketMethods<'a, C, NC, A> { + pub fn buckets(&'a self) -> BucketMethods<'a, C, A> { BucketMethods { hub: &self } } - pub fn channels(&'a self) -> ChannelMethods<'a, C, NC, A> { + pub fn channels(&'a self) -> ChannelMethods<'a, C, A> { ChannelMethods { hub: &self } } - pub fn default_object_access_controls(&'a self) -> DefaultObjectAccessControlMethods<'a, C, NC, A> { + pub fn default_object_access_controls(&'a self) -> DefaultObjectAccessControlMethods<'a, C, A> { DefaultObjectAccessControlMethods { hub: &self } } - pub fn object_access_controls(&'a self) -> ObjectAccessControlMethods<'a, C, NC, A> { + pub fn object_access_controls(&'a self) -> ObjectAccessControlMethods<'a, C, A> { ObjectAccessControlMethods { hub: &self } } - pub fn objects(&'a self) -> ObjectMethods<'a, C, NC, A> { + pub fn objects(&'a self) -> ObjectMethods<'a, C, A> { ObjectMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -1101,15 +1097,15 @@ impl ResponseResult for Buckets {} /// let rb = hub.default_object_access_controls(); /// # } /// ``` -pub struct DefaultObjectAccessControlMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DefaultObjectAccessControlMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, } -impl<'a, C, NC, A> MethodsBuilder for DefaultObjectAccessControlMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for DefaultObjectAccessControlMethods<'a, C, A> {} -impl<'a, C, NC, A> DefaultObjectAccessControlMethods<'a, C, NC, A> { +impl<'a, C, A> DefaultObjectAccessControlMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1119,7 +1115,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `bucket` - Name of a bucket. - pub fn insert(&self, request: &ObjectAccessControl, bucket: &str) -> DefaultObjectAccessControlInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &ObjectAccessControl, bucket: &str) -> DefaultObjectAccessControlInsertCall<'a, C, A> { DefaultObjectAccessControlInsertCall { hub: self.hub, _request: request.clone(), @@ -1139,7 +1135,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `bucket` - Name of a bucket. /// * `entity` - The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn update(&self, request: &ObjectAccessControl, bucket: &str, entity: &str) -> DefaultObjectAccessControlUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &ObjectAccessControl, bucket: &str, entity: &str) -> DefaultObjectAccessControlUpdateCall<'a, C, A> { DefaultObjectAccessControlUpdateCall { hub: self.hub, _request: request.clone(), @@ -1158,7 +1154,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlMethods<'a, C, NC, A> { /// # Arguments /// /// * `bucket` - Name of a bucket. - pub fn list(&self, bucket: &str) -> DefaultObjectAccessControlListCall<'a, C, NC, A> { + pub fn list(&self, bucket: &str) -> DefaultObjectAccessControlListCall<'a, C, A> { DefaultObjectAccessControlListCall { hub: self.hub, _bucket: bucket.to_string(), @@ -1179,7 +1175,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `bucket` - Name of a bucket. /// * `entity` - The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn patch(&self, request: &ObjectAccessControl, bucket: &str, entity: &str) -> DefaultObjectAccessControlPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &ObjectAccessControl, bucket: &str, entity: &str) -> DefaultObjectAccessControlPatchCall<'a, C, A> { DefaultObjectAccessControlPatchCall { hub: self.hub, _request: request.clone(), @@ -1199,7 +1195,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlMethods<'a, C, NC, A> { /// /// * `bucket` - Name of a bucket. /// * `entity` - The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn delete(&self, bucket: &str, entity: &str) -> DefaultObjectAccessControlDeleteCall<'a, C, NC, A> { + pub fn delete(&self, bucket: &str, entity: &str) -> DefaultObjectAccessControlDeleteCall<'a, C, A> { DefaultObjectAccessControlDeleteCall { hub: self.hub, _bucket: bucket.to_string(), @@ -1218,7 +1214,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlMethods<'a, C, NC, A> { /// /// * `bucket` - Name of a bucket. /// * `entity` - The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn get(&self, bucket: &str, entity: &str) -> DefaultObjectAccessControlGetCall<'a, C, NC, A> { + pub fn get(&self, bucket: &str, entity: &str) -> DefaultObjectAccessControlGetCall<'a, C, A> { DefaultObjectAccessControlGetCall { hub: self.hub, _bucket: bucket.to_string(), @@ -1260,15 +1256,15 @@ impl<'a, C, NC, A> DefaultObjectAccessControlMethods<'a, C, NC, A> { /// let rb = hub.bucket_access_controls(); /// # } /// ``` -pub struct BucketAccessControlMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BucketAccessControlMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, } -impl<'a, C, NC, A> MethodsBuilder for BucketAccessControlMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for BucketAccessControlMethods<'a, C, A> {} -impl<'a, C, NC, A> BucketAccessControlMethods<'a, C, NC, A> { +impl<'a, C, A> BucketAccessControlMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1279,7 +1275,7 @@ impl<'a, C, NC, A> BucketAccessControlMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `bucket` - Name of a bucket. /// * `entity` - The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn patch(&self, request: &BucketAccessControl, bucket: &str, entity: &str) -> BucketAccessControlPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &BucketAccessControl, bucket: &str, entity: &str) -> BucketAccessControlPatchCall<'a, C, A> { BucketAccessControlPatchCall { hub: self.hub, _request: request.clone(), @@ -1299,7 +1295,7 @@ impl<'a, C, NC, A> BucketAccessControlMethods<'a, C, NC, A> { /// /// * `bucket` - Name of a bucket. /// * `entity` - The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn delete(&self, bucket: &str, entity: &str) -> BucketAccessControlDeleteCall<'a, C, NC, A> { + pub fn delete(&self, bucket: &str, entity: &str) -> BucketAccessControlDeleteCall<'a, C, A> { BucketAccessControlDeleteCall { hub: self.hub, _bucket: bucket.to_string(), @@ -1318,7 +1314,7 @@ impl<'a, C, NC, A> BucketAccessControlMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `bucket` - Name of a bucket. - pub fn insert(&self, request: &BucketAccessControl, bucket: &str) -> BucketAccessControlInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &BucketAccessControl, bucket: &str) -> BucketAccessControlInsertCall<'a, C, A> { BucketAccessControlInsertCall { hub: self.hub, _request: request.clone(), @@ -1337,7 +1333,7 @@ impl<'a, C, NC, A> BucketAccessControlMethods<'a, C, NC, A> { /// /// * `bucket` - Name of a bucket. /// * `entity` - The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn get(&self, bucket: &str, entity: &str) -> BucketAccessControlGetCall<'a, C, NC, A> { + pub fn get(&self, bucket: &str, entity: &str) -> BucketAccessControlGetCall<'a, C, A> { BucketAccessControlGetCall { hub: self.hub, _bucket: bucket.to_string(), @@ -1357,7 +1353,7 @@ impl<'a, C, NC, A> BucketAccessControlMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `bucket` - Name of a bucket. /// * `entity` - The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn update(&self, request: &BucketAccessControl, bucket: &str, entity: &str) -> BucketAccessControlUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &BucketAccessControl, bucket: &str, entity: &str) -> BucketAccessControlUpdateCall<'a, C, A> { BucketAccessControlUpdateCall { hub: self.hub, _request: request.clone(), @@ -1376,7 +1372,7 @@ impl<'a, C, NC, A> BucketAccessControlMethods<'a, C, NC, A> { /// # Arguments /// /// * `bucket` - Name of a bucket. - pub fn list(&self, bucket: &str) -> BucketAccessControlListCall<'a, C, NC, A> { + pub fn list(&self, bucket: &str) -> BucketAccessControlListCall<'a, C, A> { BucketAccessControlListCall { hub: self.hub, _bucket: bucket.to_string(), @@ -1417,15 +1413,15 @@ impl<'a, C, NC, A> BucketAccessControlMethods<'a, C, NC, A> { /// let rb = hub.channels(); /// # } /// ``` -pub struct ChannelMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChannelMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, } -impl<'a, C, NC, A> MethodsBuilder for ChannelMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ChannelMethods<'a, C, A> {} -impl<'a, C, NC, A> ChannelMethods<'a, C, NC, A> { +impl<'a, C, A> ChannelMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1434,7 +1430,7 @@ impl<'a, C, NC, A> ChannelMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn stop(&self, request: &Channel) -> ChannelStopCall<'a, C, NC, A> { + pub fn stop(&self, request: &Channel) -> ChannelStopCall<'a, C, A> { ChannelStopCall { hub: self.hub, _request: request.clone(), @@ -1475,15 +1471,15 @@ impl<'a, C, NC, A> ChannelMethods<'a, C, NC, A> { /// let rb = hub.objects(); /// # } /// ``` -pub struct ObjectMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ObjectMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, } -impl<'a, C, NC, A> MethodsBuilder for ObjectMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ObjectMethods<'a, C, A> {} -impl<'a, C, NC, A> ObjectMethods<'a, C, NC, A> { +impl<'a, C, A> ObjectMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1493,7 +1489,7 @@ impl<'a, C, NC, A> ObjectMethods<'a, C, NC, A> { /// /// * `bucket` - Name of the bucket in which the object resides. /// * `object` - Name of the object. - pub fn get(&self, bucket: &str, object: &str) -> ObjectGetCall<'a, C, NC, A> { + pub fn get(&self, bucket: &str, object: &str) -> ObjectGetCall<'a, C, A> { ObjectGetCall { hub: self.hub, _bucket: bucket.to_string(), @@ -1521,7 +1517,7 @@ impl<'a, C, NC, A> ObjectMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `bucket` - Name of the bucket in which to look for objects. - pub fn watch_all(&self, request: &Channel, bucket: &str) -> ObjectWatchAllCall<'a, C, NC, A> { + pub fn watch_all(&self, request: &Channel, bucket: &str) -> ObjectWatchAllCall<'a, C, A> { ObjectWatchAllCall { hub: self.hub, _request: request.clone(), @@ -1547,7 +1543,7 @@ impl<'a, C, NC, A> ObjectMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `bucket` - Name of the bucket in which the object resides. /// * `object` - Name of the object. - pub fn update(&self, request: &Object, bucket: &str, object: &str) -> ObjectUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Object, bucket: &str, object: &str) -> ObjectUpdateCall<'a, C, A> { ObjectUpdateCall { hub: self.hub, _request: request.clone(), @@ -1577,7 +1573,7 @@ impl<'a, C, NC, A> ObjectMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `bucket` - Name of the bucket in which to store the new object. Overrides the provided object metadata's bucket value, if any. - pub fn insert(&self, request: &Object, bucket: &str) -> ObjectInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Object, bucket: &str) -> ObjectInsertCall<'a, C, A> { ObjectInsertCall { hub: self.hub, _request: request.clone(), @@ -1608,7 +1604,7 @@ impl<'a, C, NC, A> ObjectMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `destinationBucket` - Name of the bucket in which to store the new object. /// * `destinationObject` - Name of the new object. - pub fn compose(&self, request: &ComposeRequest, destination_bucket: &str, destination_object: &str) -> ObjectComposeCall<'a, C, NC, A> { + pub fn compose(&self, request: &ComposeRequest, destination_bucket: &str, destination_object: &str) -> ObjectComposeCall<'a, C, A> { ObjectComposeCall { hub: self.hub, _request: request.clone(), @@ -1634,7 +1630,7 @@ impl<'a, C, NC, A> ObjectMethods<'a, C, NC, A> { /// /// * `bucket` - Name of the bucket in which the object resides. /// * `object` - Name of the object. - pub fn delete(&self, bucket: &str, object: &str) -> ObjectDeleteCall<'a, C, NC, A> { + pub fn delete(&self, bucket: &str, object: &str) -> ObjectDeleteCall<'a, C, A> { ObjectDeleteCall { hub: self.hub, _bucket: bucket.to_string(), @@ -1657,7 +1653,7 @@ impl<'a, C, NC, A> ObjectMethods<'a, C, NC, A> { /// # Arguments /// /// * `bucket` - Name of the bucket in which to look for objects. - pub fn list(&self, bucket: &str) -> ObjectListCall<'a, C, NC, A> { + pub fn list(&self, bucket: &str) -> ObjectListCall<'a, C, A> { ObjectListCall { hub: self.hub, _bucket: bucket.to_string(), @@ -1684,7 +1680,7 @@ impl<'a, C, NC, A> ObjectMethods<'a, C, NC, A> { /// * `sourceObject` - Name of the source object. /// * `destinationBucket` - Name of the bucket in which to store the new object. Overrides the provided object metadata's bucket value, if any. /// * `destinationObject` - Name of the new object. Required when the object metadata is not otherwise provided. Overrides the object metadata's name value, if any. - pub fn copy(&self, request: &Object, source_bucket: &str, source_object: &str, destination_bucket: &str, destination_object: &str) -> ObjectCopyCall<'a, C, NC, A> { + pub fn copy(&self, request: &Object, source_bucket: &str, source_object: &str, destination_bucket: &str, destination_object: &str) -> ObjectCopyCall<'a, C, A> { ObjectCopyCall { hub: self.hub, _request: request.clone(), @@ -1721,7 +1717,7 @@ impl<'a, C, NC, A> ObjectMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `bucket` - Name of the bucket in which the object resides. /// * `object` - Name of the object. - pub fn patch(&self, request: &Object, bucket: &str, object: &str) -> ObjectPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Object, bucket: &str, object: &str) -> ObjectPatchCall<'a, C, A> { ObjectPatchCall { hub: self.hub, _request: request.clone(), @@ -1774,15 +1770,15 @@ impl<'a, C, NC, A> ObjectMethods<'a, C, NC, A> { /// let rb = hub.object_access_controls(); /// # } /// ``` -pub struct ObjectAccessControlMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ObjectAccessControlMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, } -impl<'a, C, NC, A> MethodsBuilder for ObjectAccessControlMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ObjectAccessControlMethods<'a, C, A> {} -impl<'a, C, NC, A> ObjectAccessControlMethods<'a, C, NC, A> { +impl<'a, C, A> ObjectAccessControlMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1793,7 +1789,7 @@ impl<'a, C, NC, A> ObjectAccessControlMethods<'a, C, NC, A> { /// * `bucket` - Name of a bucket. /// * `object` - Name of the object. /// * `entity` - The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn get(&self, bucket: &str, object: &str, entity: &str) -> ObjectAccessControlGetCall<'a, C, NC, A> { + pub fn get(&self, bucket: &str, object: &str, entity: &str) -> ObjectAccessControlGetCall<'a, C, A> { ObjectAccessControlGetCall { hub: self.hub, _bucket: bucket.to_string(), @@ -1815,7 +1811,7 @@ impl<'a, C, NC, A> ObjectAccessControlMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `bucket` - Name of a bucket. /// * `object` - Name of the object. - pub fn insert(&self, request: &ObjectAccessControl, bucket: &str, object: &str) -> ObjectAccessControlInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &ObjectAccessControl, bucket: &str, object: &str) -> ObjectAccessControlInsertCall<'a, C, A> { ObjectAccessControlInsertCall { hub: self.hub, _request: request.clone(), @@ -1838,7 +1834,7 @@ impl<'a, C, NC, A> ObjectAccessControlMethods<'a, C, NC, A> { /// * `bucket` - Name of a bucket. /// * `object` - Name of the object. /// * `entity` - The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn patch(&self, request: &ObjectAccessControl, bucket: &str, object: &str, entity: &str) -> ObjectAccessControlPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &ObjectAccessControl, bucket: &str, object: &str, entity: &str) -> ObjectAccessControlPatchCall<'a, C, A> { ObjectAccessControlPatchCall { hub: self.hub, _request: request.clone(), @@ -1860,7 +1856,7 @@ impl<'a, C, NC, A> ObjectAccessControlMethods<'a, C, NC, A> { /// /// * `bucket` - Name of a bucket. /// * `object` - Name of the object. - pub fn list(&self, bucket: &str, object: &str) -> ObjectAccessControlListCall<'a, C, NC, A> { + pub fn list(&self, bucket: &str, object: &str) -> ObjectAccessControlListCall<'a, C, A> { ObjectAccessControlListCall { hub: self.hub, _bucket: bucket.to_string(), @@ -1881,7 +1877,7 @@ impl<'a, C, NC, A> ObjectAccessControlMethods<'a, C, NC, A> { /// * `bucket` - Name of a bucket. /// * `object` - Name of the object. /// * `entity` - The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn delete(&self, bucket: &str, object: &str, entity: &str) -> ObjectAccessControlDeleteCall<'a, C, NC, A> { + pub fn delete(&self, bucket: &str, object: &str, entity: &str) -> ObjectAccessControlDeleteCall<'a, C, A> { ObjectAccessControlDeleteCall { hub: self.hub, _bucket: bucket.to_string(), @@ -1904,7 +1900,7 @@ impl<'a, C, NC, A> ObjectAccessControlMethods<'a, C, NC, A> { /// * `bucket` - Name of a bucket. /// * `object` - Name of the object. /// * `entity` - The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn update(&self, request: &ObjectAccessControl, bucket: &str, object: &str, entity: &str) -> ObjectAccessControlUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &ObjectAccessControl, bucket: &str, object: &str, entity: &str) -> ObjectAccessControlUpdateCall<'a, C, A> { ObjectAccessControlUpdateCall { hub: self.hub, _request: request.clone(), @@ -1949,15 +1945,15 @@ impl<'a, C, NC, A> ObjectAccessControlMethods<'a, C, NC, A> { /// let rb = hub.buckets(); /// # } /// ``` -pub struct BucketMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BucketMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, } -impl<'a, C, NC, A> MethodsBuilder for BucketMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for BucketMethods<'a, C, A> {} -impl<'a, C, NC, A> BucketMethods<'a, C, NC, A> { +impl<'a, C, A> BucketMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1967,7 +1963,7 @@ impl<'a, C, NC, A> BucketMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `bucket` - Name of a bucket. - pub fn update(&self, request: &Bucket, bucket: &str) -> BucketUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Bucket, bucket: &str) -> BucketUpdateCall<'a, C, A> { BucketUpdateCall { hub: self.hub, _request: request.clone(), @@ -1990,7 +1986,7 @@ impl<'a, C, NC, A> BucketMethods<'a, C, NC, A> { /// # Arguments /// /// * `bucket` - Name of a bucket. - pub fn get(&self, bucket: &str) -> BucketGetCall<'a, C, NC, A> { + pub fn get(&self, bucket: &str) -> BucketGetCall<'a, C, A> { BucketGetCall { hub: self.hub, _bucket: bucket.to_string(), @@ -2010,7 +2006,7 @@ impl<'a, C, NC, A> BucketMethods<'a, C, NC, A> { /// # Arguments /// /// * `bucket` - Name of a bucket. - pub fn delete(&self, bucket: &str) -> BucketDeleteCall<'a, C, NC, A> { + pub fn delete(&self, bucket: &str) -> BucketDeleteCall<'a, C, A> { BucketDeleteCall { hub: self.hub, _bucket: bucket.to_string(), @@ -2030,7 +2026,7 @@ impl<'a, C, NC, A> BucketMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `project` - A valid API project identifier. - pub fn insert(&self, request: &Bucket, project: &str) -> BucketInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Bucket, project: &str) -> BucketInsertCall<'a, C, A> { BucketInsertCall { hub: self.hub, _request: request.clone(), @@ -2052,7 +2048,7 @@ impl<'a, C, NC, A> BucketMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `bucket` - Name of a bucket. - pub fn patch(&self, request: &Bucket, bucket: &str) -> BucketPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Bucket, bucket: &str) -> BucketPatchCall<'a, C, A> { BucketPatchCall { hub: self.hub, _request: request.clone(), @@ -2075,7 +2071,7 @@ impl<'a, C, NC, A> BucketMethods<'a, C, NC, A> { /// # Arguments /// /// * `project` - A valid API project identifier. - pub fn list(&self, project: &str) -> BucketListCall<'a, C, NC, A> { + pub fn list(&self, project: &str) -> BucketListCall<'a, C, A> { BucketListCall { hub: self.hub, _project: project.to_string(), @@ -2134,10 +2130,10 @@ impl<'a, C, NC, A> BucketMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct DefaultObjectAccessControlInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DefaultObjectAccessControlInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _request: ObjectAccessControl, _bucket: String, _delegate: Option<&'a mut Delegate>, @@ -2145,9 +2141,9 @@ pub struct DefaultObjectAccessControlInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DefaultObjectAccessControlInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DefaultObjectAccessControlInsertCall<'a, C, A> {} -impl<'a, C, NC, A> DefaultObjectAccessControlInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DefaultObjectAccessControlInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2286,7 +2282,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlInsertCall<'a, C, NC, A> where NC: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ObjectAccessControl) -> DefaultObjectAccessControlInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ObjectAccessControl) -> DefaultObjectAccessControlInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2296,7 +2292,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlInsertCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Name of a bucket. - pub fn bucket(mut self, new_value: &str) -> DefaultObjectAccessControlInsertCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> DefaultObjectAccessControlInsertCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -2307,7 +2303,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlInsertCall<'a, C, NC, A> where NC: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DefaultObjectAccessControlInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DefaultObjectAccessControlInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2328,7 +2324,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlInsertCall<'a, C, NC, A> where NC: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DefaultObjectAccessControlInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DefaultObjectAccessControlInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2345,7 +2341,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlInsertCall<'a, C, NC, A> where NC: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DefaultObjectAccessControlInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DefaultObjectAccessControlInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2389,10 +2385,10 @@ impl<'a, C, NC, A> DefaultObjectAccessControlInsertCall<'a, C, NC, A> where NC: /// .doit(); /// # } /// ``` -pub struct DefaultObjectAccessControlUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DefaultObjectAccessControlUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _request: ObjectAccessControl, _bucket: String, _entity: String, @@ -2401,9 +2397,9 @@ pub struct DefaultObjectAccessControlUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DefaultObjectAccessControlUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DefaultObjectAccessControlUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> DefaultObjectAccessControlUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DefaultObjectAccessControlUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2543,7 +2539,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlUpdateCall<'a, C, NC, A> where NC: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ObjectAccessControl) -> DefaultObjectAccessControlUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ObjectAccessControl) -> DefaultObjectAccessControlUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2553,7 +2549,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlUpdateCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Name of a bucket. - pub fn bucket(mut self, new_value: &str) -> DefaultObjectAccessControlUpdateCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> DefaultObjectAccessControlUpdateCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -2563,7 +2559,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlUpdateCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn entity(mut self, new_value: &str) -> DefaultObjectAccessControlUpdateCall<'a, C, NC, A> { + pub fn entity(mut self, new_value: &str) -> DefaultObjectAccessControlUpdateCall<'a, C, A> { self._entity = new_value.to_string(); self } @@ -2574,7 +2570,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlUpdateCall<'a, C, NC, A> where NC: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DefaultObjectAccessControlUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DefaultObjectAccessControlUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2595,7 +2591,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlUpdateCall<'a, C, NC, A> where NC: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DefaultObjectAccessControlUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DefaultObjectAccessControlUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2612,7 +2608,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlUpdateCall<'a, C, NC, A> where NC: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DefaultObjectAccessControlUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DefaultObjectAccessControlUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2652,10 +2648,10 @@ impl<'a, C, NC, A> DefaultObjectAccessControlUpdateCall<'a, C, NC, A> where NC: /// .doit(); /// # } /// ``` -pub struct DefaultObjectAccessControlListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DefaultObjectAccessControlListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _bucket: String, _if_metageneration_not_match: Option, _if_metageneration_match: Option, @@ -2664,9 +2660,9 @@ pub struct DefaultObjectAccessControlListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DefaultObjectAccessControlListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DefaultObjectAccessControlListCall<'a, C, A> {} -impl<'a, C, NC, A> DefaultObjectAccessControlListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DefaultObjectAccessControlListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2804,7 +2800,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlListCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// Name of a bucket. - pub fn bucket(mut self, new_value: &str) -> DefaultObjectAccessControlListCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> DefaultObjectAccessControlListCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -2812,7 +2808,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlListCall<'a, C, NC, A> where NC: hy /// /// /// If present, only return default ACL listing if the bucket's current metageneration does not match the given value. - pub fn if_metageneration_not_match(mut self, new_value: &str) -> DefaultObjectAccessControlListCall<'a, C, NC, A> { + pub fn if_metageneration_not_match(mut self, new_value: &str) -> DefaultObjectAccessControlListCall<'a, C, A> { self._if_metageneration_not_match = Some(new_value.to_string()); self } @@ -2820,7 +2816,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlListCall<'a, C, NC, A> where NC: hy /// /// /// If present, only return default ACL listing if the bucket's current metageneration matches this value. - pub fn if_metageneration_match(mut self, new_value: &str) -> DefaultObjectAccessControlListCall<'a, C, NC, A> { + pub fn if_metageneration_match(mut self, new_value: &str) -> DefaultObjectAccessControlListCall<'a, C, A> { self._if_metageneration_match = Some(new_value.to_string()); self } @@ -2831,7 +2827,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlListCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DefaultObjectAccessControlListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DefaultObjectAccessControlListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2852,7 +2848,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlListCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DefaultObjectAccessControlListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DefaultObjectAccessControlListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2869,7 +2865,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlListCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DefaultObjectAccessControlListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DefaultObjectAccessControlListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2913,10 +2909,10 @@ impl<'a, C, NC, A> DefaultObjectAccessControlListCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct DefaultObjectAccessControlPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DefaultObjectAccessControlPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _request: ObjectAccessControl, _bucket: String, _entity: String, @@ -2925,9 +2921,9 @@ pub struct DefaultObjectAccessControlPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DefaultObjectAccessControlPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DefaultObjectAccessControlPatchCall<'a, C, A> {} -impl<'a, C, NC, A> DefaultObjectAccessControlPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DefaultObjectAccessControlPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3067,7 +3063,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlPatchCall<'a, C, NC, A> where NC: h /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ObjectAccessControl) -> DefaultObjectAccessControlPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ObjectAccessControl) -> DefaultObjectAccessControlPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3077,7 +3073,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlPatchCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// Name of a bucket. - pub fn bucket(mut self, new_value: &str) -> DefaultObjectAccessControlPatchCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> DefaultObjectAccessControlPatchCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -3087,7 +3083,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlPatchCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn entity(mut self, new_value: &str) -> DefaultObjectAccessControlPatchCall<'a, C, NC, A> { + pub fn entity(mut self, new_value: &str) -> DefaultObjectAccessControlPatchCall<'a, C, A> { self._entity = new_value.to_string(); self } @@ -3098,7 +3094,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlPatchCall<'a, C, NC, A> where NC: h /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DefaultObjectAccessControlPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DefaultObjectAccessControlPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3119,7 +3115,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlPatchCall<'a, C, NC, A> where NC: h /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DefaultObjectAccessControlPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DefaultObjectAccessControlPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3136,7 +3132,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlPatchCall<'a, C, NC, A> where NC: h /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DefaultObjectAccessControlPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DefaultObjectAccessControlPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3174,10 +3170,10 @@ impl<'a, C, NC, A> DefaultObjectAccessControlPatchCall<'a, C, NC, A> where NC: h /// .doit(); /// # } /// ``` -pub struct DefaultObjectAccessControlDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DefaultObjectAccessControlDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _bucket: String, _entity: String, _delegate: Option<&'a mut Delegate>, @@ -3185,9 +3181,9 @@ pub struct DefaultObjectAccessControlDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DefaultObjectAccessControlDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DefaultObjectAccessControlDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> DefaultObjectAccessControlDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DefaultObjectAccessControlDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3309,7 +3305,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlDeleteCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// Name of a bucket. - pub fn bucket(mut self, new_value: &str) -> DefaultObjectAccessControlDeleteCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> DefaultObjectAccessControlDeleteCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -3319,7 +3315,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlDeleteCall<'a, C, NC, A> where NC: /// we provide this method for API completeness. /// /// The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn entity(mut self, new_value: &str) -> DefaultObjectAccessControlDeleteCall<'a, C, NC, A> { + pub fn entity(mut self, new_value: &str) -> DefaultObjectAccessControlDeleteCall<'a, C, A> { self._entity = new_value.to_string(); self } @@ -3330,7 +3326,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlDeleteCall<'a, C, NC, A> where NC: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DefaultObjectAccessControlDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DefaultObjectAccessControlDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3351,7 +3347,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlDeleteCall<'a, C, NC, A> where NC: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DefaultObjectAccessControlDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DefaultObjectAccessControlDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3368,7 +3364,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlDeleteCall<'a, C, NC, A> where NC: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DefaultObjectAccessControlDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DefaultObjectAccessControlDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3406,10 +3402,10 @@ impl<'a, C, NC, A> DefaultObjectAccessControlDeleteCall<'a, C, NC, A> where NC: /// .doit(); /// # } /// ``` -pub struct DefaultObjectAccessControlGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DefaultObjectAccessControlGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _bucket: String, _entity: String, _delegate: Option<&'a mut Delegate>, @@ -3417,9 +3413,9 @@ pub struct DefaultObjectAccessControlGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for DefaultObjectAccessControlGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DefaultObjectAccessControlGetCall<'a, C, A> {} -impl<'a, C, NC, A> DefaultObjectAccessControlGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DefaultObjectAccessControlGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3552,7 +3548,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlGetCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// Name of a bucket. - pub fn bucket(mut self, new_value: &str) -> DefaultObjectAccessControlGetCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> DefaultObjectAccessControlGetCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -3562,7 +3558,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlGetCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn entity(mut self, new_value: &str) -> DefaultObjectAccessControlGetCall<'a, C, NC, A> { + pub fn entity(mut self, new_value: &str) -> DefaultObjectAccessControlGetCall<'a, C, A> { self._entity = new_value.to_string(); self } @@ -3573,7 +3569,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlGetCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DefaultObjectAccessControlGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DefaultObjectAccessControlGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3594,7 +3590,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlGetCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DefaultObjectAccessControlGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DefaultObjectAccessControlGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3611,7 +3607,7 @@ impl<'a, C, NC, A> DefaultObjectAccessControlGetCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> DefaultObjectAccessControlGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> DefaultObjectAccessControlGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3655,10 +3651,10 @@ impl<'a, C, NC, A> DefaultObjectAccessControlGetCall<'a, C, NC, A> where NC: hyp /// .doit(); /// # } /// ``` -pub struct BucketAccessControlPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BucketAccessControlPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _request: BucketAccessControl, _bucket: String, _entity: String, @@ -3667,9 +3663,9 @@ pub struct BucketAccessControlPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BucketAccessControlPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BucketAccessControlPatchCall<'a, C, A> {} -impl<'a, C, NC, A> BucketAccessControlPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BucketAccessControlPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3809,7 +3805,7 @@ impl<'a, C, NC, A> BucketAccessControlPatchCall<'a, C, NC, A> where NC: hyper::n /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &BucketAccessControl) -> BucketAccessControlPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &BucketAccessControl) -> BucketAccessControlPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3819,7 +3815,7 @@ impl<'a, C, NC, A> BucketAccessControlPatchCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Name of a bucket. - pub fn bucket(mut self, new_value: &str) -> BucketAccessControlPatchCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> BucketAccessControlPatchCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -3829,7 +3825,7 @@ impl<'a, C, NC, A> BucketAccessControlPatchCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn entity(mut self, new_value: &str) -> BucketAccessControlPatchCall<'a, C, NC, A> { + pub fn entity(mut self, new_value: &str) -> BucketAccessControlPatchCall<'a, C, A> { self._entity = new_value.to_string(); self } @@ -3840,7 +3836,7 @@ impl<'a, C, NC, A> BucketAccessControlPatchCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketAccessControlPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketAccessControlPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3861,7 +3857,7 @@ impl<'a, C, NC, A> BucketAccessControlPatchCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BucketAccessControlPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BucketAccessControlPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3878,7 +3874,7 @@ impl<'a, C, NC, A> BucketAccessControlPatchCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BucketAccessControlPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BucketAccessControlPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3916,10 +3912,10 @@ impl<'a, C, NC, A> BucketAccessControlPatchCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct BucketAccessControlDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BucketAccessControlDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _bucket: String, _entity: String, _delegate: Option<&'a mut Delegate>, @@ -3927,9 +3923,9 @@ pub struct BucketAccessControlDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BucketAccessControlDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BucketAccessControlDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> BucketAccessControlDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BucketAccessControlDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4051,7 +4047,7 @@ impl<'a, C, NC, A> BucketAccessControlDeleteCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Name of a bucket. - pub fn bucket(mut self, new_value: &str) -> BucketAccessControlDeleteCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> BucketAccessControlDeleteCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -4061,7 +4057,7 @@ impl<'a, C, NC, A> BucketAccessControlDeleteCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn entity(mut self, new_value: &str) -> BucketAccessControlDeleteCall<'a, C, NC, A> { + pub fn entity(mut self, new_value: &str) -> BucketAccessControlDeleteCall<'a, C, A> { self._entity = new_value.to_string(); self } @@ -4072,7 +4068,7 @@ impl<'a, C, NC, A> BucketAccessControlDeleteCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketAccessControlDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketAccessControlDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4093,7 +4089,7 @@ impl<'a, C, NC, A> BucketAccessControlDeleteCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BucketAccessControlDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BucketAccessControlDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4110,7 +4106,7 @@ impl<'a, C, NC, A> BucketAccessControlDeleteCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BucketAccessControlDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BucketAccessControlDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4154,10 +4150,10 @@ impl<'a, C, NC, A> BucketAccessControlDeleteCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct BucketAccessControlInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BucketAccessControlInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _request: BucketAccessControl, _bucket: String, _delegate: Option<&'a mut Delegate>, @@ -4165,9 +4161,9 @@ pub struct BucketAccessControlInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BucketAccessControlInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BucketAccessControlInsertCall<'a, C, A> {} -impl<'a, C, NC, A> BucketAccessControlInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BucketAccessControlInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4306,7 +4302,7 @@ impl<'a, C, NC, A> BucketAccessControlInsertCall<'a, C, NC, A> where NC: hyper:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &BucketAccessControl) -> BucketAccessControlInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &BucketAccessControl) -> BucketAccessControlInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4316,7 +4312,7 @@ impl<'a, C, NC, A> BucketAccessControlInsertCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Name of a bucket. - pub fn bucket(mut self, new_value: &str) -> BucketAccessControlInsertCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> BucketAccessControlInsertCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -4327,7 +4323,7 @@ impl<'a, C, NC, A> BucketAccessControlInsertCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketAccessControlInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketAccessControlInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4348,7 +4344,7 @@ impl<'a, C, NC, A> BucketAccessControlInsertCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BucketAccessControlInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BucketAccessControlInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4365,7 +4361,7 @@ impl<'a, C, NC, A> BucketAccessControlInsertCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BucketAccessControlInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BucketAccessControlInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4403,10 +4399,10 @@ impl<'a, C, NC, A> BucketAccessControlInsertCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct BucketAccessControlGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BucketAccessControlGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _bucket: String, _entity: String, _delegate: Option<&'a mut Delegate>, @@ -4414,9 +4410,9 @@ pub struct BucketAccessControlGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BucketAccessControlGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BucketAccessControlGetCall<'a, C, A> {} -impl<'a, C, NC, A> BucketAccessControlGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BucketAccessControlGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4549,7 +4545,7 @@ impl<'a, C, NC, A> BucketAccessControlGetCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Name of a bucket. - pub fn bucket(mut self, new_value: &str) -> BucketAccessControlGetCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> BucketAccessControlGetCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -4559,7 +4555,7 @@ impl<'a, C, NC, A> BucketAccessControlGetCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn entity(mut self, new_value: &str) -> BucketAccessControlGetCall<'a, C, NC, A> { + pub fn entity(mut self, new_value: &str) -> BucketAccessControlGetCall<'a, C, A> { self._entity = new_value.to_string(); self } @@ -4570,7 +4566,7 @@ impl<'a, C, NC, A> BucketAccessControlGetCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketAccessControlGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketAccessControlGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4591,7 +4587,7 @@ impl<'a, C, NC, A> BucketAccessControlGetCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BucketAccessControlGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BucketAccessControlGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4608,7 +4604,7 @@ impl<'a, C, NC, A> BucketAccessControlGetCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BucketAccessControlGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BucketAccessControlGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4652,10 +4648,10 @@ impl<'a, C, NC, A> BucketAccessControlGetCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct BucketAccessControlUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BucketAccessControlUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _request: BucketAccessControl, _bucket: String, _entity: String, @@ -4664,9 +4660,9 @@ pub struct BucketAccessControlUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BucketAccessControlUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BucketAccessControlUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> BucketAccessControlUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BucketAccessControlUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4806,7 +4802,7 @@ impl<'a, C, NC, A> BucketAccessControlUpdateCall<'a, C, NC, A> where NC: hyper:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &BucketAccessControl) -> BucketAccessControlUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &BucketAccessControl) -> BucketAccessControlUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4816,7 +4812,7 @@ impl<'a, C, NC, A> BucketAccessControlUpdateCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Name of a bucket. - pub fn bucket(mut self, new_value: &str) -> BucketAccessControlUpdateCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> BucketAccessControlUpdateCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -4826,7 +4822,7 @@ impl<'a, C, NC, A> BucketAccessControlUpdateCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn entity(mut self, new_value: &str) -> BucketAccessControlUpdateCall<'a, C, NC, A> { + pub fn entity(mut self, new_value: &str) -> BucketAccessControlUpdateCall<'a, C, A> { self._entity = new_value.to_string(); self } @@ -4837,7 +4833,7 @@ impl<'a, C, NC, A> BucketAccessControlUpdateCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketAccessControlUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketAccessControlUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4858,7 +4854,7 @@ impl<'a, C, NC, A> BucketAccessControlUpdateCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BucketAccessControlUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BucketAccessControlUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4875,7 +4871,7 @@ impl<'a, C, NC, A> BucketAccessControlUpdateCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BucketAccessControlUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BucketAccessControlUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4913,19 +4909,19 @@ impl<'a, C, NC, A> BucketAccessControlUpdateCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct BucketAccessControlListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BucketAccessControlListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _bucket: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BucketAccessControlListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BucketAccessControlListCall<'a, C, A> {} -impl<'a, C, NC, A> BucketAccessControlListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BucketAccessControlListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5057,7 +5053,7 @@ impl<'a, C, NC, A> BucketAccessControlListCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Name of a bucket. - pub fn bucket(mut self, new_value: &str) -> BucketAccessControlListCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> BucketAccessControlListCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -5068,7 +5064,7 @@ impl<'a, C, NC, A> BucketAccessControlListCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketAccessControlListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketAccessControlListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5089,7 +5085,7 @@ impl<'a, C, NC, A> BucketAccessControlListCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BucketAccessControlListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BucketAccessControlListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5106,7 +5102,7 @@ impl<'a, C, NC, A> BucketAccessControlListCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BucketAccessControlListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BucketAccessControlListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5150,19 +5146,19 @@ impl<'a, C, NC, A> BucketAccessControlListCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct ChannelStopCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChannelStopCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _request: Channel, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChannelStopCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChannelStopCall<'a, C, A> {} -impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChannelStopCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5265,7 +5261,7 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Channel) -> ChannelStopCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Channel) -> ChannelStopCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5276,7 +5272,7 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelStopCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelStopCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5297,7 +5293,7 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChannelStopCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChannelStopCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5314,7 +5310,7 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChannelStopCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChannelStopCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5366,10 +5362,10 @@ impl<'a, C, NC, A> ChannelStopCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct ObjectGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ObjectGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _bucket: String, _object: String, _projection: Option, @@ -5386,9 +5382,9 @@ pub struct ObjectGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ObjectGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ObjectGetCall<'a, C, A> {} -impl<'a, C, NC, A> ObjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ObjectGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5564,7 +5560,7 @@ impl<'a, C, NC, A> ObjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Name of the bucket in which the object resides. - pub fn bucket(mut self, new_value: &str) -> ObjectGetCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> ObjectGetCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -5574,7 +5570,7 @@ impl<'a, C, NC, A> ObjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Name of the object. - pub fn object(mut self, new_value: &str) -> ObjectGetCall<'a, C, NC, A> { + pub fn object(mut self, new_value: &str) -> ObjectGetCall<'a, C, A> { self._object = new_value.to_string(); self } @@ -5582,7 +5578,7 @@ impl<'a, C, NC, A> ObjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Set of properties to return. Defaults to noAcl. - pub fn projection(mut self, new_value: &str) -> ObjectGetCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> ObjectGetCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -5590,7 +5586,7 @@ impl<'a, C, NC, A> ObjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Makes the operation conditional on whether the object's current metageneration does not match the given value. - pub fn if_metageneration_not_match(mut self, new_value: &str) -> ObjectGetCall<'a, C, NC, A> { + pub fn if_metageneration_not_match(mut self, new_value: &str) -> ObjectGetCall<'a, C, A> { self._if_metageneration_not_match = Some(new_value.to_string()); self } @@ -5598,7 +5594,7 @@ impl<'a, C, NC, A> ObjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Makes the operation conditional on whether the object's current metageneration matches the given value. - pub fn if_metageneration_match(mut self, new_value: &str) -> ObjectGetCall<'a, C, NC, A> { + pub fn if_metageneration_match(mut self, new_value: &str) -> ObjectGetCall<'a, C, A> { self._if_metageneration_match = Some(new_value.to_string()); self } @@ -5606,7 +5602,7 @@ impl<'a, C, NC, A> ObjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Makes the operation conditional on whether the object's generation does not match the given value. - pub fn if_generation_not_match(mut self, new_value: &str) -> ObjectGetCall<'a, C, NC, A> { + pub fn if_generation_not_match(mut self, new_value: &str) -> ObjectGetCall<'a, C, A> { self._if_generation_not_match = Some(new_value.to_string()); self } @@ -5614,7 +5610,7 @@ impl<'a, C, NC, A> ObjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Makes the operation conditional on whether the object's generation matches the given value. - pub fn if_generation_match(mut self, new_value: &str) -> ObjectGetCall<'a, C, NC, A> { + pub fn if_generation_match(mut self, new_value: &str) -> ObjectGetCall<'a, C, A> { self._if_generation_match = Some(new_value.to_string()); self } @@ -5622,7 +5618,7 @@ impl<'a, C, NC, A> ObjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// If present, selects a specific revision of this object (as opposed to the latest version, the default). - pub fn generation(mut self, new_value: &str) -> ObjectGetCall<'a, C, NC, A> { + pub fn generation(mut self, new_value: &str) -> ObjectGetCall<'a, C, A> { self._generation = Some(new_value.to_string()); self } @@ -5630,7 +5626,7 @@ impl<'a, C, NC, A> ObjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Provides the digest of the key for error-checking transmission. A digest is in the format of '='. Algorithm, key, and key hash must be supplied together. - pub fn encryption_key_hash(mut self, new_value: &str) -> ObjectGetCall<'a, C, NC, A> { + pub fn encryption_key_hash(mut self, new_value: &str) -> ObjectGetCall<'a, C, A> { self._encryption_key_hash = Some(new_value.to_string()); self } @@ -5638,7 +5634,7 @@ impl<'a, C, NC, A> ObjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Provides a base64-encoded 256-bit key to decrypt the object. Algorithm, key, and key hash must be supplied together. - pub fn encryption_key(mut self, new_value: &str) -> ObjectGetCall<'a, C, NC, A> { + pub fn encryption_key(mut self, new_value: &str) -> ObjectGetCall<'a, C, A> { self._encryption_key = Some(new_value.to_string()); self } @@ -5646,7 +5642,7 @@ impl<'a, C, NC, A> ObjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Specifies the encryption algorithm that would be used to decrypt the object. Only 'AES256' is supported currently. Algorithm, key, and key hash must be supplied together. - pub fn encryption_algorithm(mut self, new_value: &str) -> ObjectGetCall<'a, C, NC, A> { + pub fn encryption_algorithm(mut self, new_value: &str) -> ObjectGetCall<'a, C, A> { self._encryption_algorithm = Some(new_value.to_string()); self } @@ -5657,7 +5653,7 @@ impl<'a, C, NC, A> ObjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5678,7 +5674,7 @@ impl<'a, C, NC, A> ObjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ObjectGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ObjectGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5695,7 +5691,7 @@ impl<'a, C, NC, A> ObjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ObjectGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ObjectGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5745,10 +5741,10 @@ impl<'a, C, NC, A> ObjectGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct ObjectWatchAllCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ObjectWatchAllCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _request: Channel, _bucket: String, _versions: Option, @@ -5762,9 +5758,9 @@ pub struct ObjectWatchAllCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ObjectWatchAllCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ObjectWatchAllCall<'a, C, A> {} -impl<'a, C, NC, A> ObjectWatchAllCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ObjectWatchAllCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5921,7 +5917,7 @@ impl<'a, C, NC, A> ObjectWatchAllCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Channel) -> ObjectWatchAllCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Channel) -> ObjectWatchAllCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5931,7 +5927,7 @@ impl<'a, C, NC, A> ObjectWatchAllCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Name of the bucket in which to look for objects. - pub fn bucket(mut self, new_value: &str) -> ObjectWatchAllCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> ObjectWatchAllCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -5939,7 +5935,7 @@ impl<'a, C, NC, A> ObjectWatchAllCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// If true, lists all versions of a file as distinct results. - pub fn versions(mut self, new_value: bool) -> ObjectWatchAllCall<'a, C, NC, A> { + pub fn versions(mut self, new_value: bool) -> ObjectWatchAllCall<'a, C, A> { self._versions = Some(new_value); self } @@ -5947,7 +5943,7 @@ impl<'a, C, NC, A> ObjectWatchAllCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Set of properties to return. Defaults to noAcl. - pub fn projection(mut self, new_value: &str) -> ObjectWatchAllCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> ObjectWatchAllCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -5955,7 +5951,7 @@ impl<'a, C, NC, A> ObjectWatchAllCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Filter results to objects whose names begin with this prefix. - pub fn prefix(mut self, new_value: &str) -> ObjectWatchAllCall<'a, C, NC, A> { + pub fn prefix(mut self, new_value: &str) -> ObjectWatchAllCall<'a, C, A> { self._prefix = Some(new_value.to_string()); self } @@ -5963,7 +5959,7 @@ impl<'a, C, NC, A> ObjectWatchAllCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// A previously-returned page token representing part of the larger set of results to view. - pub fn page_token(mut self, new_value: &str) -> ObjectWatchAllCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ObjectWatchAllCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -5971,7 +5967,7 @@ impl<'a, C, NC, A> ObjectWatchAllCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Maximum number of items plus prefixes to return. As duplicate prefixes are omitted, fewer total results may be returned than requested. - pub fn max_results(mut self, new_value: u32) -> ObjectWatchAllCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> ObjectWatchAllCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -5979,7 +5975,7 @@ impl<'a, C, NC, A> ObjectWatchAllCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// Returns results in a directory-like mode. items will contain only objects whose names, aside from the prefix, do not contain delimiter. Objects whose names, aside from the prefix, contain delimiter will have their name, truncated after the delimiter, returned in prefixes. Duplicate prefixes are omitted. - pub fn delimiter(mut self, new_value: &str) -> ObjectWatchAllCall<'a, C, NC, A> { + pub fn delimiter(mut self, new_value: &str) -> ObjectWatchAllCall<'a, C, A> { self._delimiter = Some(new_value.to_string()); self } @@ -5990,7 +5986,7 @@ impl<'a, C, NC, A> ObjectWatchAllCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectWatchAllCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectWatchAllCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6011,7 +6007,7 @@ impl<'a, C, NC, A> ObjectWatchAllCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ObjectWatchAllCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ObjectWatchAllCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6028,7 +6024,7 @@ impl<'a, C, NC, A> ObjectWatchAllCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ObjectWatchAllCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ObjectWatchAllCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6087,10 +6083,10 @@ impl<'a, C, NC, A> ObjectWatchAllCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct ObjectUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ObjectUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _request: Object, _bucket: String, _object: String, @@ -6109,9 +6105,9 @@ pub struct ObjectUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ObjectUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ObjectUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ObjectUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ObjectUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6297,7 +6293,7 @@ impl<'a, C, NC, A> ObjectUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Object) -> ObjectUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Object) -> ObjectUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6307,7 +6303,7 @@ impl<'a, C, NC, A> ObjectUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Name of the bucket in which the object resides. - pub fn bucket(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -6317,7 +6313,7 @@ impl<'a, C, NC, A> ObjectUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Name of the object. - pub fn object(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, NC, A> { + pub fn object(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, A> { self._object = new_value.to_string(); self } @@ -6325,7 +6321,7 @@ impl<'a, C, NC, A> ObjectUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Set of properties to return. Defaults to full. - pub fn projection(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -6333,7 +6329,7 @@ impl<'a, C, NC, A> ObjectUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Apply a predefined set of access controls to this object. - pub fn predefined_acl(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, NC, A> { + pub fn predefined_acl(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, A> { self._predefined_acl = Some(new_value.to_string()); self } @@ -6341,7 +6337,7 @@ impl<'a, C, NC, A> ObjectUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Makes the operation conditional on whether the object's current metageneration does not match the given value. - pub fn if_metageneration_not_match(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, NC, A> { + pub fn if_metageneration_not_match(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, A> { self._if_metageneration_not_match = Some(new_value.to_string()); self } @@ -6349,7 +6345,7 @@ impl<'a, C, NC, A> ObjectUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Makes the operation conditional on whether the object's current metageneration matches the given value. - pub fn if_metageneration_match(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, NC, A> { + pub fn if_metageneration_match(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, A> { self._if_metageneration_match = Some(new_value.to_string()); self } @@ -6357,7 +6353,7 @@ impl<'a, C, NC, A> ObjectUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Makes the operation conditional on whether the object's current generation does not match the given value. - pub fn if_generation_not_match(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, NC, A> { + pub fn if_generation_not_match(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, A> { self._if_generation_not_match = Some(new_value.to_string()); self } @@ -6365,7 +6361,7 @@ impl<'a, C, NC, A> ObjectUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Makes the operation conditional on whether the object's current generation matches the given value. - pub fn if_generation_match(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, NC, A> { + pub fn if_generation_match(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, A> { self._if_generation_match = Some(new_value.to_string()); self } @@ -6373,7 +6369,7 @@ impl<'a, C, NC, A> ObjectUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// If present, selects a specific revision of this object (as opposed to the latest version, the default). - pub fn generation(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, NC, A> { + pub fn generation(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, A> { self._generation = Some(new_value.to_string()); self } @@ -6381,7 +6377,7 @@ impl<'a, C, NC, A> ObjectUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// For downloading encrypted objects, provides the digest of the key for error-checking transmission. A digest is in the format of '='. Algorithm, key, and key hash must be supplied together. - pub fn encryption_key_hash(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, NC, A> { + pub fn encryption_key_hash(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, A> { self._encryption_key_hash = Some(new_value.to_string()); self } @@ -6389,7 +6385,7 @@ impl<'a, C, NC, A> ObjectUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// For downloading encrypted objects, provides a base64-encoded 256-bit key to decrypt the object. Algorithm, key, and key hash must be supplied together. - pub fn encryption_key(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, NC, A> { + pub fn encryption_key(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, A> { self._encryption_key = Some(new_value.to_string()); self } @@ -6397,7 +6393,7 @@ impl<'a, C, NC, A> ObjectUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// For downloading encrypted objects, specifies the encryption algorithm that would be used to decrypt the object. Only 'AES256' is supported currently. Algorithm, key, and key hash must be supplied together. - pub fn encryption_algorithm(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, NC, A> { + pub fn encryption_algorithm(mut self, new_value: &str) -> ObjectUpdateCall<'a, C, A> { self._encryption_algorithm = Some(new_value.to_string()); self } @@ -6408,7 +6404,7 @@ impl<'a, C, NC, A> ObjectUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6429,7 +6425,7 @@ impl<'a, C, NC, A> ObjectUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ObjectUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ObjectUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6446,7 +6442,7 @@ impl<'a, C, NC, A> ObjectUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ObjectUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ObjectUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6507,10 +6503,10 @@ impl<'a, C, NC, A> ObjectUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .upload(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct ObjectInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ObjectInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _request: Object, _bucket: String, _projection: Option, @@ -6529,9 +6525,9 @@ pub struct ObjectInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ObjectInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ObjectInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ObjectInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ObjectInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6829,7 +6825,7 @@ impl<'a, C, NC, A> ObjectInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Object) -> ObjectInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Object) -> ObjectInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6839,7 +6835,7 @@ impl<'a, C, NC, A> ObjectInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Name of the bucket in which to store the new object. Overrides the provided object metadata's bucket value, if any. - pub fn bucket(mut self, new_value: &str) -> ObjectInsertCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> ObjectInsertCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -6847,7 +6843,7 @@ impl<'a, C, NC, A> ObjectInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Set of properties to return. Defaults to noAcl, unless the object resource specifies the acl property, when it defaults to full. - pub fn projection(mut self, new_value: &str) -> ObjectInsertCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> ObjectInsertCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -6855,7 +6851,7 @@ impl<'a, C, NC, A> ObjectInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Apply a predefined set of access controls to this object. - pub fn predefined_acl(mut self, new_value: &str) -> ObjectInsertCall<'a, C, NC, A> { + pub fn predefined_acl(mut self, new_value: &str) -> ObjectInsertCall<'a, C, A> { self._predefined_acl = Some(new_value.to_string()); self } @@ -6863,7 +6859,7 @@ impl<'a, C, NC, A> ObjectInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Name of the object. Required when the object metadata is not otherwise provided. Overrides the object metadata's name value, if any. - pub fn name(mut self, new_value: &str) -> ObjectInsertCall<'a, C, NC, A> { + pub fn name(mut self, new_value: &str) -> ObjectInsertCall<'a, C, A> { self._name = Some(new_value.to_string()); self } @@ -6871,7 +6867,7 @@ impl<'a, C, NC, A> ObjectInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Makes the operation conditional on whether the object's current metageneration does not match the given value. - pub fn if_metageneration_not_match(mut self, new_value: &str) -> ObjectInsertCall<'a, C, NC, A> { + pub fn if_metageneration_not_match(mut self, new_value: &str) -> ObjectInsertCall<'a, C, A> { self._if_metageneration_not_match = Some(new_value.to_string()); self } @@ -6879,7 +6875,7 @@ impl<'a, C, NC, A> ObjectInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Makes the operation conditional on whether the object's current metageneration matches the given value. - pub fn if_metageneration_match(mut self, new_value: &str) -> ObjectInsertCall<'a, C, NC, A> { + pub fn if_metageneration_match(mut self, new_value: &str) -> ObjectInsertCall<'a, C, A> { self._if_metageneration_match = Some(new_value.to_string()); self } @@ -6887,7 +6883,7 @@ impl<'a, C, NC, A> ObjectInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Makes the operation conditional on whether the object's current generation does not match the given value. - pub fn if_generation_not_match(mut self, new_value: &str) -> ObjectInsertCall<'a, C, NC, A> { + pub fn if_generation_not_match(mut self, new_value: &str) -> ObjectInsertCall<'a, C, A> { self._if_generation_not_match = Some(new_value.to_string()); self } @@ -6895,7 +6891,7 @@ impl<'a, C, NC, A> ObjectInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Makes the operation conditional on whether the object's current generation matches the given value. - pub fn if_generation_match(mut self, new_value: &str) -> ObjectInsertCall<'a, C, NC, A> { + pub fn if_generation_match(mut self, new_value: &str) -> ObjectInsertCall<'a, C, A> { self._if_generation_match = Some(new_value.to_string()); self } @@ -6903,7 +6899,7 @@ impl<'a, C, NC, A> ObjectInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Provides the digest of the key for error-checking transmission. A digest is in the format of '='. Algorithm, key, and key hash must be supplied together. - pub fn encryption_key_hash(mut self, new_value: &str) -> ObjectInsertCall<'a, C, NC, A> { + pub fn encryption_key_hash(mut self, new_value: &str) -> ObjectInsertCall<'a, C, A> { self._encryption_key_hash = Some(new_value.to_string()); self } @@ -6911,7 +6907,7 @@ impl<'a, C, NC, A> ObjectInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Provides a base64-encoded 256-bit key to encrypt the object. Algorithm, key, and key hash must be supplied together. - pub fn encryption_key(mut self, new_value: &str) -> ObjectInsertCall<'a, C, NC, A> { + pub fn encryption_key(mut self, new_value: &str) -> ObjectInsertCall<'a, C, A> { self._encryption_key = Some(new_value.to_string()); self } @@ -6919,7 +6915,7 @@ impl<'a, C, NC, A> ObjectInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Specifies the encryption algorithm that would be used to encrypt the object. Only 'AES256' is supported currently. Algorithm, key, and key hash must be supplied together. - pub fn encryption_algorithm(mut self, new_value: &str) -> ObjectInsertCall<'a, C, NC, A> { + pub fn encryption_algorithm(mut self, new_value: &str) -> ObjectInsertCall<'a, C, A> { self._encryption_algorithm = Some(new_value.to_string()); self } @@ -6927,7 +6923,7 @@ impl<'a, C, NC, A> ObjectInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// If set, sets the contentEncoding property of the final object to this value. Setting this parameter is equivalent to setting the contentEncoding metadata property. This can be useful when uploading an object with uploadType=media to indicate the encoding of the content being uploaded. - pub fn content_encoding(mut self, new_value: &str) -> ObjectInsertCall<'a, C, NC, A> { + pub fn content_encoding(mut self, new_value: &str) -> ObjectInsertCall<'a, C, A> { self._content_encoding = Some(new_value.to_string()); self } @@ -6938,7 +6934,7 @@ impl<'a, C, NC, A> ObjectInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6959,7 +6955,7 @@ impl<'a, C, NC, A> ObjectInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ObjectInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ObjectInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6976,7 +6972,7 @@ impl<'a, C, NC, A> ObjectInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ObjectInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ObjectInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7031,10 +7027,10 @@ impl<'a, C, NC, A> ObjectInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct ObjectComposeCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ObjectComposeCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _request: ComposeRequest, _destination_bucket: String, _destination_object: String, @@ -7049,9 +7045,9 @@ pub struct ObjectComposeCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ObjectComposeCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ObjectComposeCall<'a, C, A> {} -impl<'a, C, NC, A> ObjectComposeCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ObjectComposeCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7225,7 +7221,7 @@ impl<'a, C, NC, A> ObjectComposeCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ComposeRequest) -> ObjectComposeCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ComposeRequest) -> ObjectComposeCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7235,7 +7231,7 @@ impl<'a, C, NC, A> ObjectComposeCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Name of the bucket in which to store the new object. - pub fn destination_bucket(mut self, new_value: &str) -> ObjectComposeCall<'a, C, NC, A> { + pub fn destination_bucket(mut self, new_value: &str) -> ObjectComposeCall<'a, C, A> { self._destination_bucket = new_value.to_string(); self } @@ -7245,7 +7241,7 @@ impl<'a, C, NC, A> ObjectComposeCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Name of the new object. - pub fn destination_object(mut self, new_value: &str) -> ObjectComposeCall<'a, C, NC, A> { + pub fn destination_object(mut self, new_value: &str) -> ObjectComposeCall<'a, C, A> { self._destination_object = new_value.to_string(); self } @@ -7253,7 +7249,7 @@ impl<'a, C, NC, A> ObjectComposeCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Makes the operation conditional on whether the object's current metageneration matches the given value. - pub fn if_metageneration_match(mut self, new_value: &str) -> ObjectComposeCall<'a, C, NC, A> { + pub fn if_metageneration_match(mut self, new_value: &str) -> ObjectComposeCall<'a, C, A> { self._if_metageneration_match = Some(new_value.to_string()); self } @@ -7261,7 +7257,7 @@ impl<'a, C, NC, A> ObjectComposeCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Makes the operation conditional on whether the object's current generation matches the given value. - pub fn if_generation_match(mut self, new_value: &str) -> ObjectComposeCall<'a, C, NC, A> { + pub fn if_generation_match(mut self, new_value: &str) -> ObjectComposeCall<'a, C, A> { self._if_generation_match = Some(new_value.to_string()); self } @@ -7269,7 +7265,7 @@ impl<'a, C, NC, A> ObjectComposeCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Provides the digest of the key for error-checking transmission. A digest is in the format of '='. Algorithm, key, and key hash must be supplied together. - pub fn encryption_key_hash(mut self, new_value: &str) -> ObjectComposeCall<'a, C, NC, A> { + pub fn encryption_key_hash(mut self, new_value: &str) -> ObjectComposeCall<'a, C, A> { self._encryption_key_hash = Some(new_value.to_string()); self } @@ -7277,7 +7273,7 @@ impl<'a, C, NC, A> ObjectComposeCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Provides a base64-encoded 256-bit key that was used to encrypt the object, if any. Algorithm, key, and key hash must be supplied together. - pub fn encryption_key(mut self, new_value: &str) -> ObjectComposeCall<'a, C, NC, A> { + pub fn encryption_key(mut self, new_value: &str) -> ObjectComposeCall<'a, C, A> { self._encryption_key = Some(new_value.to_string()); self } @@ -7285,7 +7281,7 @@ impl<'a, C, NC, A> ObjectComposeCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Specifies the encryption algorithm that was used to encrypt the object, if any. Only 'AES256' is supported currently. Algorithm, key, and key hash must be supplied together. - pub fn encryption_algorithm(mut self, new_value: &str) -> ObjectComposeCall<'a, C, NC, A> { + pub fn encryption_algorithm(mut self, new_value: &str) -> ObjectComposeCall<'a, C, A> { self._encryption_algorithm = Some(new_value.to_string()); self } @@ -7293,7 +7289,7 @@ impl<'a, C, NC, A> ObjectComposeCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// Apply a predefined set of access controls to the destination object. - pub fn destination_predefined_acl(mut self, new_value: &str) -> ObjectComposeCall<'a, C, NC, A> { + pub fn destination_predefined_acl(mut self, new_value: &str) -> ObjectComposeCall<'a, C, A> { self._destination_predefined_acl = Some(new_value.to_string()); self } @@ -7304,7 +7300,7 @@ impl<'a, C, NC, A> ObjectComposeCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectComposeCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectComposeCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7325,7 +7321,7 @@ impl<'a, C, NC, A> ObjectComposeCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ObjectComposeCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ObjectComposeCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7342,7 +7338,7 @@ impl<'a, C, NC, A> ObjectComposeCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ObjectComposeCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ObjectComposeCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7385,10 +7381,10 @@ impl<'a, C, NC, A> ObjectComposeCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct ObjectDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ObjectDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _bucket: String, _object: String, _if_metageneration_not_match: Option, @@ -7401,9 +7397,9 @@ pub struct ObjectDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ObjectDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ObjectDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ObjectDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ObjectDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7540,7 +7536,7 @@ impl<'a, C, NC, A> ObjectDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Name of the bucket in which the object resides. - pub fn bucket(mut self, new_value: &str) -> ObjectDeleteCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> ObjectDeleteCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -7550,7 +7546,7 @@ impl<'a, C, NC, A> ObjectDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Name of the object. - pub fn object(mut self, new_value: &str) -> ObjectDeleteCall<'a, C, NC, A> { + pub fn object(mut self, new_value: &str) -> ObjectDeleteCall<'a, C, A> { self._object = new_value.to_string(); self } @@ -7558,7 +7554,7 @@ impl<'a, C, NC, A> ObjectDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Makes the operation conditional on whether the object's current metageneration does not match the given value. - pub fn if_metageneration_not_match(mut self, new_value: &str) -> ObjectDeleteCall<'a, C, NC, A> { + pub fn if_metageneration_not_match(mut self, new_value: &str) -> ObjectDeleteCall<'a, C, A> { self._if_metageneration_not_match = Some(new_value.to_string()); self } @@ -7566,7 +7562,7 @@ impl<'a, C, NC, A> ObjectDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Makes the operation conditional on whether the object's current metageneration matches the given value. - pub fn if_metageneration_match(mut self, new_value: &str) -> ObjectDeleteCall<'a, C, NC, A> { + pub fn if_metageneration_match(mut self, new_value: &str) -> ObjectDeleteCall<'a, C, A> { self._if_metageneration_match = Some(new_value.to_string()); self } @@ -7574,7 +7570,7 @@ impl<'a, C, NC, A> ObjectDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Makes the operation conditional on whether the object's current generation does not match the given value. - pub fn if_generation_not_match(mut self, new_value: &str) -> ObjectDeleteCall<'a, C, NC, A> { + pub fn if_generation_not_match(mut self, new_value: &str) -> ObjectDeleteCall<'a, C, A> { self._if_generation_not_match = Some(new_value.to_string()); self } @@ -7582,7 +7578,7 @@ impl<'a, C, NC, A> ObjectDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Makes the operation conditional on whether the object's current generation matches the given value. - pub fn if_generation_match(mut self, new_value: &str) -> ObjectDeleteCall<'a, C, NC, A> { + pub fn if_generation_match(mut self, new_value: &str) -> ObjectDeleteCall<'a, C, A> { self._if_generation_match = Some(new_value.to_string()); self } @@ -7590,7 +7586,7 @@ impl<'a, C, NC, A> ObjectDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// If present, permanently deletes a specific revision of this object (as opposed to the latest version, the default). - pub fn generation(mut self, new_value: &str) -> ObjectDeleteCall<'a, C, NC, A> { + pub fn generation(mut self, new_value: &str) -> ObjectDeleteCall<'a, C, A> { self._generation = Some(new_value.to_string()); self } @@ -7601,7 +7597,7 @@ impl<'a, C, NC, A> ObjectDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7622,7 +7618,7 @@ impl<'a, C, NC, A> ObjectDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ObjectDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ObjectDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7639,7 +7635,7 @@ impl<'a, C, NC, A> ObjectDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ObjectDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ObjectDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7683,10 +7679,10 @@ impl<'a, C, NC, A> ObjectDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct ObjectListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ObjectListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _bucket: String, _versions: Option, _projection: Option, @@ -7699,9 +7695,9 @@ pub struct ObjectListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ObjectListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ObjectListCall<'a, C, A> {} -impl<'a, C, NC, A> ObjectListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ObjectListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7851,7 +7847,7 @@ impl<'a, C, NC, A> ObjectListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Name of the bucket in which to look for objects. - pub fn bucket(mut self, new_value: &str) -> ObjectListCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> ObjectListCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -7859,7 +7855,7 @@ impl<'a, C, NC, A> ObjectListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// If true, lists all versions of a file as distinct results. - pub fn versions(mut self, new_value: bool) -> ObjectListCall<'a, C, NC, A> { + pub fn versions(mut self, new_value: bool) -> ObjectListCall<'a, C, A> { self._versions = Some(new_value); self } @@ -7867,7 +7863,7 @@ impl<'a, C, NC, A> ObjectListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Set of properties to return. Defaults to noAcl. - pub fn projection(mut self, new_value: &str) -> ObjectListCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> ObjectListCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -7875,7 +7871,7 @@ impl<'a, C, NC, A> ObjectListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Filter results to objects whose names begin with this prefix. - pub fn prefix(mut self, new_value: &str) -> ObjectListCall<'a, C, NC, A> { + pub fn prefix(mut self, new_value: &str) -> ObjectListCall<'a, C, A> { self._prefix = Some(new_value.to_string()); self } @@ -7883,7 +7879,7 @@ impl<'a, C, NC, A> ObjectListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// A previously-returned page token representing part of the larger set of results to view. - pub fn page_token(mut self, new_value: &str) -> ObjectListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ObjectListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -7891,7 +7887,7 @@ impl<'a, C, NC, A> ObjectListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Maximum number of items plus prefixes to return. As duplicate prefixes are omitted, fewer total results may be returned than requested. - pub fn max_results(mut self, new_value: u32) -> ObjectListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> ObjectListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -7899,7 +7895,7 @@ impl<'a, C, NC, A> ObjectListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Returns results in a directory-like mode. items will contain only objects whose names, aside from the prefix, do not contain delimiter. Objects whose names, aside from the prefix, contain delimiter will have their name, truncated after the delimiter, returned in prefixes. Duplicate prefixes are omitted. - pub fn delimiter(mut self, new_value: &str) -> ObjectListCall<'a, C, NC, A> { + pub fn delimiter(mut self, new_value: &str) -> ObjectListCall<'a, C, A> { self._delimiter = Some(new_value.to_string()); self } @@ -7910,7 +7906,7 @@ impl<'a, C, NC, A> ObjectListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7931,7 +7927,7 @@ impl<'a, C, NC, A> ObjectListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ObjectListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ObjectListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7948,7 +7944,7 @@ impl<'a, C, NC, A> ObjectListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ObjectListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ObjectListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8011,10 +8007,10 @@ impl<'a, C, NC, A> ObjectListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct ObjectCopyCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ObjectCopyCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _request: Object, _source_bucket: String, _source_object: String, @@ -8039,9 +8035,9 @@ pub struct ObjectCopyCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ObjectCopyCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ObjectCopyCall<'a, C, A> {} -impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ObjectCopyCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8241,7 +8237,7 @@ impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Object) -> ObjectCopyCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Object) -> ObjectCopyCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8251,7 +8247,7 @@ impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Name of the bucket in which to find the source object. - pub fn source_bucket(mut self, new_value: &str) -> ObjectCopyCall<'a, C, NC, A> { + pub fn source_bucket(mut self, new_value: &str) -> ObjectCopyCall<'a, C, A> { self._source_bucket = new_value.to_string(); self } @@ -8261,7 +8257,7 @@ impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Name of the source object. - pub fn source_object(mut self, new_value: &str) -> ObjectCopyCall<'a, C, NC, A> { + pub fn source_object(mut self, new_value: &str) -> ObjectCopyCall<'a, C, A> { self._source_object = new_value.to_string(); self } @@ -8271,7 +8267,7 @@ impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Name of the bucket in which to store the new object. Overrides the provided object metadata's bucket value, if any. - pub fn destination_bucket(mut self, new_value: &str) -> ObjectCopyCall<'a, C, NC, A> { + pub fn destination_bucket(mut self, new_value: &str) -> ObjectCopyCall<'a, C, A> { self._destination_bucket = new_value.to_string(); self } @@ -8281,7 +8277,7 @@ impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Name of the new object. Required when the object metadata is not otherwise provided. Overrides the object metadata's name value, if any. - pub fn destination_object(mut self, new_value: &str) -> ObjectCopyCall<'a, C, NC, A> { + pub fn destination_object(mut self, new_value: &str) -> ObjectCopyCall<'a, C, A> { self._destination_object = new_value.to_string(); self } @@ -8289,7 +8285,7 @@ impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// If present, selects a specific revision of the source object (as opposed to the latest version, the default). - pub fn source_generation(mut self, new_value: &str) -> ObjectCopyCall<'a, C, NC, A> { + pub fn source_generation(mut self, new_value: &str) -> ObjectCopyCall<'a, C, A> { self._source_generation = Some(new_value.to_string()); self } @@ -8297,7 +8293,7 @@ impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Set of properties to return. Defaults to noAcl, unless the object resource specifies the acl property, when it defaults to full. - pub fn projection(mut self, new_value: &str) -> ObjectCopyCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> ObjectCopyCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -8305,7 +8301,7 @@ impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Makes the operation conditional on whether the source object's current metageneration does not match the given value. - pub fn if_source_metageneration_not_match(mut self, new_value: &str) -> ObjectCopyCall<'a, C, NC, A> { + pub fn if_source_metageneration_not_match(mut self, new_value: &str) -> ObjectCopyCall<'a, C, A> { self._if_source_metageneration_not_match = Some(new_value.to_string()); self } @@ -8313,7 +8309,7 @@ impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Makes the operation conditional on whether the source object's current metageneration matches the given value. - pub fn if_source_metageneration_match(mut self, new_value: &str) -> ObjectCopyCall<'a, C, NC, A> { + pub fn if_source_metageneration_match(mut self, new_value: &str) -> ObjectCopyCall<'a, C, A> { self._if_source_metageneration_match = Some(new_value.to_string()); self } @@ -8321,7 +8317,7 @@ impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Makes the operation conditional on whether the source object's generation does not match the given value. - pub fn if_source_generation_not_match(mut self, new_value: &str) -> ObjectCopyCall<'a, C, NC, A> { + pub fn if_source_generation_not_match(mut self, new_value: &str) -> ObjectCopyCall<'a, C, A> { self._if_source_generation_not_match = Some(new_value.to_string()); self } @@ -8329,7 +8325,7 @@ impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Makes the operation conditional on whether the source object's generation matches the given value. - pub fn if_source_generation_match(mut self, new_value: &str) -> ObjectCopyCall<'a, C, NC, A> { + pub fn if_source_generation_match(mut self, new_value: &str) -> ObjectCopyCall<'a, C, A> { self._if_source_generation_match = Some(new_value.to_string()); self } @@ -8337,7 +8333,7 @@ impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Makes the operation conditional on whether the destination object's current metageneration does not match the given value. - pub fn if_metageneration_not_match(mut self, new_value: &str) -> ObjectCopyCall<'a, C, NC, A> { + pub fn if_metageneration_not_match(mut self, new_value: &str) -> ObjectCopyCall<'a, C, A> { self._if_metageneration_not_match = Some(new_value.to_string()); self } @@ -8345,7 +8341,7 @@ impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Makes the operation conditional on whether the destination object's current metageneration matches the given value. - pub fn if_metageneration_match(mut self, new_value: &str) -> ObjectCopyCall<'a, C, NC, A> { + pub fn if_metageneration_match(mut self, new_value: &str) -> ObjectCopyCall<'a, C, A> { self._if_metageneration_match = Some(new_value.to_string()); self } @@ -8353,7 +8349,7 @@ impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Makes the operation conditional on whether the destination object's current generation does not match the given value. - pub fn if_generation_not_match(mut self, new_value: &str) -> ObjectCopyCall<'a, C, NC, A> { + pub fn if_generation_not_match(mut self, new_value: &str) -> ObjectCopyCall<'a, C, A> { self._if_generation_not_match = Some(new_value.to_string()); self } @@ -8361,7 +8357,7 @@ impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Makes the operation conditional on whether the destination object's current generation matches the given value. - pub fn if_generation_match(mut self, new_value: &str) -> ObjectCopyCall<'a, C, NC, A> { + pub fn if_generation_match(mut self, new_value: &str) -> ObjectCopyCall<'a, C, A> { self._if_generation_match = Some(new_value.to_string()); self } @@ -8369,7 +8365,7 @@ impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Provides the digest of the key for error-checking transmission. A digest is in the format of '='. Algorithm, key, and key hash must be supplied together. - pub fn encryption_key_hash(mut self, new_value: &str) -> ObjectCopyCall<'a, C, NC, A> { + pub fn encryption_key_hash(mut self, new_value: &str) -> ObjectCopyCall<'a, C, A> { self._encryption_key_hash = Some(new_value.to_string()); self } @@ -8377,7 +8373,7 @@ impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Provides a base64-encoded 256-bit key that was used to encrypt the object, if any. Algorithm, key, and key hash must be supplied together. - pub fn encryption_key(mut self, new_value: &str) -> ObjectCopyCall<'a, C, NC, A> { + pub fn encryption_key(mut self, new_value: &str) -> ObjectCopyCall<'a, C, A> { self._encryption_key = Some(new_value.to_string()); self } @@ -8385,7 +8381,7 @@ impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Specifies the encryption algorithm that was used to encrypt the object, if any. Only 'AES256' is supported currently. Algorithm, key, and key hash must be supplied together. - pub fn encryption_algorithm(mut self, new_value: &str) -> ObjectCopyCall<'a, C, NC, A> { + pub fn encryption_algorithm(mut self, new_value: &str) -> ObjectCopyCall<'a, C, A> { self._encryption_algorithm = Some(new_value.to_string()); self } @@ -8393,7 +8389,7 @@ impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Apply a predefined set of access controls to the destination object. - pub fn destination_predefined_acl(mut self, new_value: &str) -> ObjectCopyCall<'a, C, NC, A> { + pub fn destination_predefined_acl(mut self, new_value: &str) -> ObjectCopyCall<'a, C, A> { self._destination_predefined_acl = Some(new_value.to_string()); self } @@ -8404,7 +8400,7 @@ impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectCopyCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectCopyCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8425,7 +8421,7 @@ impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ObjectCopyCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ObjectCopyCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8442,7 +8438,7 @@ impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ObjectCopyCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ObjectCopyCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8496,10 +8492,10 @@ impl<'a, C, NC, A> ObjectCopyCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct ObjectPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ObjectPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _request: Object, _bucket: String, _object: String, @@ -8518,9 +8514,9 @@ pub struct ObjectPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ObjectPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ObjectPatchCall<'a, C, A> {} -impl<'a, C, NC, A> ObjectPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ObjectPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8690,7 +8686,7 @@ impl<'a, C, NC, A> ObjectPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Object) -> ObjectPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Object) -> ObjectPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8700,7 +8696,7 @@ impl<'a, C, NC, A> ObjectPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Name of the bucket in which the object resides. - pub fn bucket(mut self, new_value: &str) -> ObjectPatchCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> ObjectPatchCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -8710,7 +8706,7 @@ impl<'a, C, NC, A> ObjectPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Name of the object. - pub fn object(mut self, new_value: &str) -> ObjectPatchCall<'a, C, NC, A> { + pub fn object(mut self, new_value: &str) -> ObjectPatchCall<'a, C, A> { self._object = new_value.to_string(); self } @@ -8718,7 +8714,7 @@ impl<'a, C, NC, A> ObjectPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Set of properties to return. Defaults to full. - pub fn projection(mut self, new_value: &str) -> ObjectPatchCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> ObjectPatchCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -8726,7 +8722,7 @@ impl<'a, C, NC, A> ObjectPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Apply a predefined set of access controls to this object. - pub fn predefined_acl(mut self, new_value: &str) -> ObjectPatchCall<'a, C, NC, A> { + pub fn predefined_acl(mut self, new_value: &str) -> ObjectPatchCall<'a, C, A> { self._predefined_acl = Some(new_value.to_string()); self } @@ -8734,7 +8730,7 @@ impl<'a, C, NC, A> ObjectPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Makes the operation conditional on whether the object's current metageneration does not match the given value. - pub fn if_metageneration_not_match(mut self, new_value: &str) -> ObjectPatchCall<'a, C, NC, A> { + pub fn if_metageneration_not_match(mut self, new_value: &str) -> ObjectPatchCall<'a, C, A> { self._if_metageneration_not_match = Some(new_value.to_string()); self } @@ -8742,7 +8738,7 @@ impl<'a, C, NC, A> ObjectPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Makes the operation conditional on whether the object's current metageneration matches the given value. - pub fn if_metageneration_match(mut self, new_value: &str) -> ObjectPatchCall<'a, C, NC, A> { + pub fn if_metageneration_match(mut self, new_value: &str) -> ObjectPatchCall<'a, C, A> { self._if_metageneration_match = Some(new_value.to_string()); self } @@ -8750,7 +8746,7 @@ impl<'a, C, NC, A> ObjectPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Makes the operation conditional on whether the object's current generation does not match the given value. - pub fn if_generation_not_match(mut self, new_value: &str) -> ObjectPatchCall<'a, C, NC, A> { + pub fn if_generation_not_match(mut self, new_value: &str) -> ObjectPatchCall<'a, C, A> { self._if_generation_not_match = Some(new_value.to_string()); self } @@ -8758,7 +8754,7 @@ impl<'a, C, NC, A> ObjectPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Makes the operation conditional on whether the object's current generation matches the given value. - pub fn if_generation_match(mut self, new_value: &str) -> ObjectPatchCall<'a, C, NC, A> { + pub fn if_generation_match(mut self, new_value: &str) -> ObjectPatchCall<'a, C, A> { self._if_generation_match = Some(new_value.to_string()); self } @@ -8766,7 +8762,7 @@ impl<'a, C, NC, A> ObjectPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// If present, selects a specific revision of this object (as opposed to the latest version, the default). - pub fn generation(mut self, new_value: &str) -> ObjectPatchCall<'a, C, NC, A> { + pub fn generation(mut self, new_value: &str) -> ObjectPatchCall<'a, C, A> { self._generation = Some(new_value.to_string()); self } @@ -8774,7 +8770,7 @@ impl<'a, C, NC, A> ObjectPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// For downloading encrypted objects, provides the digest of the key for error-checking transmission. A digest is in the format of '='. Algorithm, key, and key hash must be supplied together. - pub fn encryption_key_hash(mut self, new_value: &str) -> ObjectPatchCall<'a, C, NC, A> { + pub fn encryption_key_hash(mut self, new_value: &str) -> ObjectPatchCall<'a, C, A> { self._encryption_key_hash = Some(new_value.to_string()); self } @@ -8782,7 +8778,7 @@ impl<'a, C, NC, A> ObjectPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// For downloading encrypted objects, provides a base64-encoded 256-bit key to decrypt the object. Algorithm, key, and key hash must be supplied together. - pub fn encryption_key(mut self, new_value: &str) -> ObjectPatchCall<'a, C, NC, A> { + pub fn encryption_key(mut self, new_value: &str) -> ObjectPatchCall<'a, C, A> { self._encryption_key = Some(new_value.to_string()); self } @@ -8790,7 +8786,7 @@ impl<'a, C, NC, A> ObjectPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// For downloading encrypted objects, specifies the encryption algorithm that would be used to decrypt the object. Only 'AES256' is supported currently. Algorithm, key, and key hash must be supplied together. - pub fn encryption_algorithm(mut self, new_value: &str) -> ObjectPatchCall<'a, C, NC, A> { + pub fn encryption_algorithm(mut self, new_value: &str) -> ObjectPatchCall<'a, C, A> { self._encryption_algorithm = Some(new_value.to_string()); self } @@ -8801,7 +8797,7 @@ impl<'a, C, NC, A> ObjectPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8822,7 +8818,7 @@ impl<'a, C, NC, A> ObjectPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ObjectPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ObjectPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8839,7 +8835,7 @@ impl<'a, C, NC, A> ObjectPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ObjectPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ObjectPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8878,10 +8874,10 @@ impl<'a, C, NC, A> ObjectPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct ObjectAccessControlGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ObjectAccessControlGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _bucket: String, _object: String, _entity: String, @@ -8891,9 +8887,9 @@ pub struct ObjectAccessControlGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ObjectAccessControlGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ObjectAccessControlGetCall<'a, C, A> {} -impl<'a, C, NC, A> ObjectAccessControlGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ObjectAccessControlGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9030,7 +9026,7 @@ impl<'a, C, NC, A> ObjectAccessControlGetCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Name of a bucket. - pub fn bucket(mut self, new_value: &str) -> ObjectAccessControlGetCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> ObjectAccessControlGetCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -9040,7 +9036,7 @@ impl<'a, C, NC, A> ObjectAccessControlGetCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// Name of the object. - pub fn object(mut self, new_value: &str) -> ObjectAccessControlGetCall<'a, C, NC, A> { + pub fn object(mut self, new_value: &str) -> ObjectAccessControlGetCall<'a, C, A> { self._object = new_value.to_string(); self } @@ -9050,7 +9046,7 @@ impl<'a, C, NC, A> ObjectAccessControlGetCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn entity(mut self, new_value: &str) -> ObjectAccessControlGetCall<'a, C, NC, A> { + pub fn entity(mut self, new_value: &str) -> ObjectAccessControlGetCall<'a, C, A> { self._entity = new_value.to_string(); self } @@ -9058,7 +9054,7 @@ impl<'a, C, NC, A> ObjectAccessControlGetCall<'a, C, NC, A> where NC: hyper::net /// /// /// If present, selects a specific revision of this object (as opposed to the latest version, the default). - pub fn generation(mut self, new_value: &str) -> ObjectAccessControlGetCall<'a, C, NC, A> { + pub fn generation(mut self, new_value: &str) -> ObjectAccessControlGetCall<'a, C, A> { self._generation = Some(new_value.to_string()); self } @@ -9069,7 +9065,7 @@ impl<'a, C, NC, A> ObjectAccessControlGetCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectAccessControlGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectAccessControlGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9090,7 +9086,7 @@ impl<'a, C, NC, A> ObjectAccessControlGetCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ObjectAccessControlGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ObjectAccessControlGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9107,7 +9103,7 @@ impl<'a, C, NC, A> ObjectAccessControlGetCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ObjectAccessControlGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ObjectAccessControlGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9152,10 +9148,10 @@ impl<'a, C, NC, A> ObjectAccessControlGetCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct ObjectAccessControlInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ObjectAccessControlInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _request: ObjectAccessControl, _bucket: String, _object: String, @@ -9165,9 +9161,9 @@ pub struct ObjectAccessControlInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ObjectAccessControlInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ObjectAccessControlInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ObjectAccessControlInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ObjectAccessControlInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9310,7 +9306,7 @@ impl<'a, C, NC, A> ObjectAccessControlInsertCall<'a, C, NC, A> where NC: hyper:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ObjectAccessControl) -> ObjectAccessControlInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ObjectAccessControl) -> ObjectAccessControlInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9320,7 +9316,7 @@ impl<'a, C, NC, A> ObjectAccessControlInsertCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Name of a bucket. - pub fn bucket(mut self, new_value: &str) -> ObjectAccessControlInsertCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> ObjectAccessControlInsertCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -9330,7 +9326,7 @@ impl<'a, C, NC, A> ObjectAccessControlInsertCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Name of the object. - pub fn object(mut self, new_value: &str) -> ObjectAccessControlInsertCall<'a, C, NC, A> { + pub fn object(mut self, new_value: &str) -> ObjectAccessControlInsertCall<'a, C, A> { self._object = new_value.to_string(); self } @@ -9338,7 +9334,7 @@ impl<'a, C, NC, A> ObjectAccessControlInsertCall<'a, C, NC, A> where NC: hyper:: /// /// /// If present, selects a specific revision of this object (as opposed to the latest version, the default). - pub fn generation(mut self, new_value: &str) -> ObjectAccessControlInsertCall<'a, C, NC, A> { + pub fn generation(mut self, new_value: &str) -> ObjectAccessControlInsertCall<'a, C, A> { self._generation = Some(new_value.to_string()); self } @@ -9349,7 +9345,7 @@ impl<'a, C, NC, A> ObjectAccessControlInsertCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectAccessControlInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectAccessControlInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9370,7 +9366,7 @@ impl<'a, C, NC, A> ObjectAccessControlInsertCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ObjectAccessControlInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ObjectAccessControlInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9387,7 +9383,7 @@ impl<'a, C, NC, A> ObjectAccessControlInsertCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ObjectAccessControlInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ObjectAccessControlInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9432,10 +9428,10 @@ impl<'a, C, NC, A> ObjectAccessControlInsertCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct ObjectAccessControlPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ObjectAccessControlPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _request: ObjectAccessControl, _bucket: String, _object: String, @@ -9446,9 +9442,9 @@ pub struct ObjectAccessControlPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ObjectAccessControlPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ObjectAccessControlPatchCall<'a, C, A> {} -impl<'a, C, NC, A> ObjectAccessControlPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ObjectAccessControlPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9592,7 +9588,7 @@ impl<'a, C, NC, A> ObjectAccessControlPatchCall<'a, C, NC, A> where NC: hyper::n /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ObjectAccessControl) -> ObjectAccessControlPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ObjectAccessControl) -> ObjectAccessControlPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9602,7 +9598,7 @@ impl<'a, C, NC, A> ObjectAccessControlPatchCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Name of a bucket. - pub fn bucket(mut self, new_value: &str) -> ObjectAccessControlPatchCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> ObjectAccessControlPatchCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -9612,7 +9608,7 @@ impl<'a, C, NC, A> ObjectAccessControlPatchCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// Name of the object. - pub fn object(mut self, new_value: &str) -> ObjectAccessControlPatchCall<'a, C, NC, A> { + pub fn object(mut self, new_value: &str) -> ObjectAccessControlPatchCall<'a, C, A> { self._object = new_value.to_string(); self } @@ -9622,7 +9618,7 @@ impl<'a, C, NC, A> ObjectAccessControlPatchCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn entity(mut self, new_value: &str) -> ObjectAccessControlPatchCall<'a, C, NC, A> { + pub fn entity(mut self, new_value: &str) -> ObjectAccessControlPatchCall<'a, C, A> { self._entity = new_value.to_string(); self } @@ -9630,7 +9626,7 @@ impl<'a, C, NC, A> ObjectAccessControlPatchCall<'a, C, NC, A> where NC: hyper::n /// /// /// If present, selects a specific revision of this object (as opposed to the latest version, the default). - pub fn generation(mut self, new_value: &str) -> ObjectAccessControlPatchCall<'a, C, NC, A> { + pub fn generation(mut self, new_value: &str) -> ObjectAccessControlPatchCall<'a, C, A> { self._generation = Some(new_value.to_string()); self } @@ -9641,7 +9637,7 @@ impl<'a, C, NC, A> ObjectAccessControlPatchCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectAccessControlPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectAccessControlPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9662,7 +9658,7 @@ impl<'a, C, NC, A> ObjectAccessControlPatchCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ObjectAccessControlPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ObjectAccessControlPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9679,7 +9675,7 @@ impl<'a, C, NC, A> ObjectAccessControlPatchCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ObjectAccessControlPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ObjectAccessControlPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9718,10 +9714,10 @@ impl<'a, C, NC, A> ObjectAccessControlPatchCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct ObjectAccessControlListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ObjectAccessControlListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _bucket: String, _object: String, _generation: Option, @@ -9730,9 +9726,9 @@ pub struct ObjectAccessControlListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ObjectAccessControlListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ObjectAccessControlListCall<'a, C, A> {} -impl<'a, C, NC, A> ObjectAccessControlListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ObjectAccessControlListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9868,7 +9864,7 @@ impl<'a, C, NC, A> ObjectAccessControlListCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Name of a bucket. - pub fn bucket(mut self, new_value: &str) -> ObjectAccessControlListCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> ObjectAccessControlListCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -9878,7 +9874,7 @@ impl<'a, C, NC, A> ObjectAccessControlListCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// Name of the object. - pub fn object(mut self, new_value: &str) -> ObjectAccessControlListCall<'a, C, NC, A> { + pub fn object(mut self, new_value: &str) -> ObjectAccessControlListCall<'a, C, A> { self._object = new_value.to_string(); self } @@ -9886,7 +9882,7 @@ impl<'a, C, NC, A> ObjectAccessControlListCall<'a, C, NC, A> where NC: hyper::ne /// /// /// If present, selects a specific revision of this object (as opposed to the latest version, the default). - pub fn generation(mut self, new_value: &str) -> ObjectAccessControlListCall<'a, C, NC, A> { + pub fn generation(mut self, new_value: &str) -> ObjectAccessControlListCall<'a, C, A> { self._generation = Some(new_value.to_string()); self } @@ -9897,7 +9893,7 @@ impl<'a, C, NC, A> ObjectAccessControlListCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectAccessControlListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectAccessControlListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9918,7 +9914,7 @@ impl<'a, C, NC, A> ObjectAccessControlListCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ObjectAccessControlListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ObjectAccessControlListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9935,7 +9931,7 @@ impl<'a, C, NC, A> ObjectAccessControlListCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ObjectAccessControlListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ObjectAccessControlListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9974,10 +9970,10 @@ impl<'a, C, NC, A> ObjectAccessControlListCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct ObjectAccessControlDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ObjectAccessControlDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _bucket: String, _object: String, _entity: String, @@ -9987,9 +9983,9 @@ pub struct ObjectAccessControlDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ObjectAccessControlDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ObjectAccessControlDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ObjectAccessControlDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ObjectAccessControlDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10115,7 +10111,7 @@ impl<'a, C, NC, A> ObjectAccessControlDeleteCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Name of a bucket. - pub fn bucket(mut self, new_value: &str) -> ObjectAccessControlDeleteCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> ObjectAccessControlDeleteCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -10125,7 +10121,7 @@ impl<'a, C, NC, A> ObjectAccessControlDeleteCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Name of the object. - pub fn object(mut self, new_value: &str) -> ObjectAccessControlDeleteCall<'a, C, NC, A> { + pub fn object(mut self, new_value: &str) -> ObjectAccessControlDeleteCall<'a, C, A> { self._object = new_value.to_string(); self } @@ -10135,7 +10131,7 @@ impl<'a, C, NC, A> ObjectAccessControlDeleteCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn entity(mut self, new_value: &str) -> ObjectAccessControlDeleteCall<'a, C, NC, A> { + pub fn entity(mut self, new_value: &str) -> ObjectAccessControlDeleteCall<'a, C, A> { self._entity = new_value.to_string(); self } @@ -10143,7 +10139,7 @@ impl<'a, C, NC, A> ObjectAccessControlDeleteCall<'a, C, NC, A> where NC: hyper:: /// /// /// If present, selects a specific revision of this object (as opposed to the latest version, the default). - pub fn generation(mut self, new_value: &str) -> ObjectAccessControlDeleteCall<'a, C, NC, A> { + pub fn generation(mut self, new_value: &str) -> ObjectAccessControlDeleteCall<'a, C, A> { self._generation = Some(new_value.to_string()); self } @@ -10154,7 +10150,7 @@ impl<'a, C, NC, A> ObjectAccessControlDeleteCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectAccessControlDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectAccessControlDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10175,7 +10171,7 @@ impl<'a, C, NC, A> ObjectAccessControlDeleteCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ObjectAccessControlDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ObjectAccessControlDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10192,7 +10188,7 @@ impl<'a, C, NC, A> ObjectAccessControlDeleteCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ObjectAccessControlDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ObjectAccessControlDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10237,10 +10233,10 @@ impl<'a, C, NC, A> ObjectAccessControlDeleteCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct ObjectAccessControlUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ObjectAccessControlUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _request: ObjectAccessControl, _bucket: String, _object: String, @@ -10251,9 +10247,9 @@ pub struct ObjectAccessControlUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ObjectAccessControlUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ObjectAccessControlUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ObjectAccessControlUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ObjectAccessControlUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10397,7 +10393,7 @@ impl<'a, C, NC, A> ObjectAccessControlUpdateCall<'a, C, NC, A> where NC: hyper:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ObjectAccessControl) -> ObjectAccessControlUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ObjectAccessControl) -> ObjectAccessControlUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -10407,7 +10403,7 @@ impl<'a, C, NC, A> ObjectAccessControlUpdateCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Name of a bucket. - pub fn bucket(mut self, new_value: &str) -> ObjectAccessControlUpdateCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> ObjectAccessControlUpdateCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -10417,7 +10413,7 @@ impl<'a, C, NC, A> ObjectAccessControlUpdateCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// Name of the object. - pub fn object(mut self, new_value: &str) -> ObjectAccessControlUpdateCall<'a, C, NC, A> { + pub fn object(mut self, new_value: &str) -> ObjectAccessControlUpdateCall<'a, C, A> { self._object = new_value.to_string(); self } @@ -10427,7 +10423,7 @@ impl<'a, C, NC, A> ObjectAccessControlUpdateCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The entity holding the permission. Can be user-userId, user-emailAddress, group-groupId, group-emailAddress, allUsers, or allAuthenticatedUsers. - pub fn entity(mut self, new_value: &str) -> ObjectAccessControlUpdateCall<'a, C, NC, A> { + pub fn entity(mut self, new_value: &str) -> ObjectAccessControlUpdateCall<'a, C, A> { self._entity = new_value.to_string(); self } @@ -10435,7 +10431,7 @@ impl<'a, C, NC, A> ObjectAccessControlUpdateCall<'a, C, NC, A> where NC: hyper:: /// /// /// If present, selects a specific revision of this object (as opposed to the latest version, the default). - pub fn generation(mut self, new_value: &str) -> ObjectAccessControlUpdateCall<'a, C, NC, A> { + pub fn generation(mut self, new_value: &str) -> ObjectAccessControlUpdateCall<'a, C, A> { self._generation = Some(new_value.to_string()); self } @@ -10446,7 +10442,7 @@ impl<'a, C, NC, A> ObjectAccessControlUpdateCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectAccessControlUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ObjectAccessControlUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10467,7 +10463,7 @@ impl<'a, C, NC, A> ObjectAccessControlUpdateCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ObjectAccessControlUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ObjectAccessControlUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10484,7 +10480,7 @@ impl<'a, C, NC, A> ObjectAccessControlUpdateCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ObjectAccessControlUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ObjectAccessControlUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10533,10 +10529,10 @@ impl<'a, C, NC, A> ObjectAccessControlUpdateCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct BucketUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BucketUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _request: Bucket, _bucket: String, _projection: Option, @@ -10549,9 +10545,9 @@ pub struct BucketUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BucketUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BucketUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> BucketUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BucketUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10705,7 +10701,7 @@ impl<'a, C, NC, A> BucketUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Bucket) -> BucketUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Bucket) -> BucketUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -10715,7 +10711,7 @@ impl<'a, C, NC, A> BucketUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Name of a bucket. - pub fn bucket(mut self, new_value: &str) -> BucketUpdateCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> BucketUpdateCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -10723,7 +10719,7 @@ impl<'a, C, NC, A> BucketUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Set of properties to return. Defaults to full. - pub fn projection(mut self, new_value: &str) -> BucketUpdateCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> BucketUpdateCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -10731,7 +10727,7 @@ impl<'a, C, NC, A> BucketUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Apply a predefined set of default object access controls to this bucket. - pub fn predefined_default_object_acl(mut self, new_value: &str) -> BucketUpdateCall<'a, C, NC, A> { + pub fn predefined_default_object_acl(mut self, new_value: &str) -> BucketUpdateCall<'a, C, A> { self._predefined_default_object_acl = Some(new_value.to_string()); self } @@ -10739,7 +10735,7 @@ impl<'a, C, NC, A> BucketUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Apply a predefined set of access controls to this bucket. - pub fn predefined_acl(mut self, new_value: &str) -> BucketUpdateCall<'a, C, NC, A> { + pub fn predefined_acl(mut self, new_value: &str) -> BucketUpdateCall<'a, C, A> { self._predefined_acl = Some(new_value.to_string()); self } @@ -10747,7 +10743,7 @@ impl<'a, C, NC, A> BucketUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Makes the return of the bucket metadata conditional on whether the bucket's current metageneration does not match the given value. - pub fn if_metageneration_not_match(mut self, new_value: &str) -> BucketUpdateCall<'a, C, NC, A> { + pub fn if_metageneration_not_match(mut self, new_value: &str) -> BucketUpdateCall<'a, C, A> { self._if_metageneration_not_match = Some(new_value.to_string()); self } @@ -10755,7 +10751,7 @@ impl<'a, C, NC, A> BucketUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Makes the return of the bucket metadata conditional on whether the bucket's current metageneration matches the given value. - pub fn if_metageneration_match(mut self, new_value: &str) -> BucketUpdateCall<'a, C, NC, A> { + pub fn if_metageneration_match(mut self, new_value: &str) -> BucketUpdateCall<'a, C, A> { self._if_metageneration_match = Some(new_value.to_string()); self } @@ -10766,7 +10762,7 @@ impl<'a, C, NC, A> BucketUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10787,7 +10783,7 @@ impl<'a, C, NC, A> BucketUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BucketUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BucketUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10804,7 +10800,7 @@ impl<'a, C, NC, A> BucketUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BucketUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BucketUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10845,10 +10841,10 @@ impl<'a, C, NC, A> BucketUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct BucketGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BucketGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _bucket: String, _projection: Option, _if_metageneration_not_match: Option, @@ -10858,9 +10854,9 @@ pub struct BucketGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BucketGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BucketGetCall<'a, C, A> {} -impl<'a, C, NC, A> BucketGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BucketGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11001,7 +10997,7 @@ impl<'a, C, NC, A> BucketGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Name of a bucket. - pub fn bucket(mut self, new_value: &str) -> BucketGetCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> BucketGetCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -11009,7 +11005,7 @@ impl<'a, C, NC, A> BucketGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Set of properties to return. Defaults to noAcl. - pub fn projection(mut self, new_value: &str) -> BucketGetCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> BucketGetCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -11017,7 +11013,7 @@ impl<'a, C, NC, A> BucketGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Makes the return of the bucket metadata conditional on whether the bucket's current metageneration does not match the given value. - pub fn if_metageneration_not_match(mut self, new_value: &str) -> BucketGetCall<'a, C, NC, A> { + pub fn if_metageneration_not_match(mut self, new_value: &str) -> BucketGetCall<'a, C, A> { self._if_metageneration_not_match = Some(new_value.to_string()); self } @@ -11025,7 +11021,7 @@ impl<'a, C, NC, A> BucketGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Makes the return of the bucket metadata conditional on whether the bucket's current metageneration matches the given value. - pub fn if_metageneration_match(mut self, new_value: &str) -> BucketGetCall<'a, C, NC, A> { + pub fn if_metageneration_match(mut self, new_value: &str) -> BucketGetCall<'a, C, A> { self._if_metageneration_match = Some(new_value.to_string()); self } @@ -11036,7 +11032,7 @@ impl<'a, C, NC, A> BucketGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11057,7 +11053,7 @@ impl<'a, C, NC, A> BucketGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BucketGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BucketGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11074,7 +11070,7 @@ impl<'a, C, NC, A> BucketGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BucketGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BucketGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11114,10 +11110,10 @@ impl<'a, C, NC, A> BucketGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct BucketDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BucketDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _bucket: String, _if_metageneration_not_match: Option, _if_metageneration_match: Option, @@ -11126,9 +11122,9 @@ pub struct BucketDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BucketDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BucketDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> BucketDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BucketDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11255,7 +11251,7 @@ impl<'a, C, NC, A> BucketDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// Name of a bucket. - pub fn bucket(mut self, new_value: &str) -> BucketDeleteCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> BucketDeleteCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -11263,7 +11259,7 @@ impl<'a, C, NC, A> BucketDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// If set, only deletes the bucket if its metageneration does not match this value. - pub fn if_metageneration_not_match(mut self, new_value: &str) -> BucketDeleteCall<'a, C, NC, A> { + pub fn if_metageneration_not_match(mut self, new_value: &str) -> BucketDeleteCall<'a, C, A> { self._if_metageneration_not_match = Some(new_value.to_string()); self } @@ -11271,7 +11267,7 @@ impl<'a, C, NC, A> BucketDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// If set, only deletes the bucket if its metageneration matches this value. - pub fn if_metageneration_match(mut self, new_value: &str) -> BucketDeleteCall<'a, C, NC, A> { + pub fn if_metageneration_match(mut self, new_value: &str) -> BucketDeleteCall<'a, C, A> { self._if_metageneration_match = Some(new_value.to_string()); self } @@ -11282,7 +11278,7 @@ impl<'a, C, NC, A> BucketDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11303,7 +11299,7 @@ impl<'a, C, NC, A> BucketDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BucketDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BucketDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11320,7 +11316,7 @@ impl<'a, C, NC, A> BucketDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BucketDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BucketDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11367,10 +11363,10 @@ impl<'a, C, NC, A> BucketDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct BucketInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BucketInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _request: Bucket, _project: String, _projection: Option, @@ -11381,9 +11377,9 @@ pub struct BucketInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BucketInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BucketInsertCall<'a, C, A> {} -impl<'a, C, NC, A> BucketInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BucketInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11507,7 +11503,7 @@ impl<'a, C, NC, A> BucketInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Bucket) -> BucketInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Bucket) -> BucketInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -11517,7 +11513,7 @@ impl<'a, C, NC, A> BucketInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// A valid API project identifier. - pub fn project(mut self, new_value: &str) -> BucketInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> BucketInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -11525,7 +11521,7 @@ impl<'a, C, NC, A> BucketInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Set of properties to return. Defaults to noAcl, unless the bucket resource specifies acl or defaultObjectAcl properties, when it defaults to full. - pub fn projection(mut self, new_value: &str) -> BucketInsertCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> BucketInsertCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -11533,7 +11529,7 @@ impl<'a, C, NC, A> BucketInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Apply a predefined set of default object access controls to this bucket. - pub fn predefined_default_object_acl(mut self, new_value: &str) -> BucketInsertCall<'a, C, NC, A> { + pub fn predefined_default_object_acl(mut self, new_value: &str) -> BucketInsertCall<'a, C, A> { self._predefined_default_object_acl = Some(new_value.to_string()); self } @@ -11541,7 +11537,7 @@ impl<'a, C, NC, A> BucketInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Apply a predefined set of access controls to this bucket. - pub fn predefined_acl(mut self, new_value: &str) -> BucketInsertCall<'a, C, NC, A> { + pub fn predefined_acl(mut self, new_value: &str) -> BucketInsertCall<'a, C, A> { self._predefined_acl = Some(new_value.to_string()); self } @@ -11552,7 +11548,7 @@ impl<'a, C, NC, A> BucketInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11573,7 +11569,7 @@ impl<'a, C, NC, A> BucketInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BucketInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BucketInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11590,7 +11586,7 @@ impl<'a, C, NC, A> BucketInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BucketInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BucketInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11639,10 +11635,10 @@ impl<'a, C, NC, A> BucketInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct BucketPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BucketPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _request: Bucket, _bucket: String, _projection: Option, @@ -11655,9 +11651,9 @@ pub struct BucketPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BucketPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BucketPatchCall<'a, C, A> {} -impl<'a, C, NC, A> BucketPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BucketPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11811,7 +11807,7 @@ impl<'a, C, NC, A> BucketPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Bucket) -> BucketPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Bucket) -> BucketPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -11821,7 +11817,7 @@ impl<'a, C, NC, A> BucketPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Name of a bucket. - pub fn bucket(mut self, new_value: &str) -> BucketPatchCall<'a, C, NC, A> { + pub fn bucket(mut self, new_value: &str) -> BucketPatchCall<'a, C, A> { self._bucket = new_value.to_string(); self } @@ -11829,7 +11825,7 @@ impl<'a, C, NC, A> BucketPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Set of properties to return. Defaults to full. - pub fn projection(mut self, new_value: &str) -> BucketPatchCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> BucketPatchCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -11837,7 +11833,7 @@ impl<'a, C, NC, A> BucketPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Apply a predefined set of default object access controls to this bucket. - pub fn predefined_default_object_acl(mut self, new_value: &str) -> BucketPatchCall<'a, C, NC, A> { + pub fn predefined_default_object_acl(mut self, new_value: &str) -> BucketPatchCall<'a, C, A> { self._predefined_default_object_acl = Some(new_value.to_string()); self } @@ -11845,7 +11841,7 @@ impl<'a, C, NC, A> BucketPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Apply a predefined set of access controls to this bucket. - pub fn predefined_acl(mut self, new_value: &str) -> BucketPatchCall<'a, C, NC, A> { + pub fn predefined_acl(mut self, new_value: &str) -> BucketPatchCall<'a, C, A> { self._predefined_acl = Some(new_value.to_string()); self } @@ -11853,7 +11849,7 @@ impl<'a, C, NC, A> BucketPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Makes the return of the bucket metadata conditional on whether the bucket's current metageneration does not match the given value. - pub fn if_metageneration_not_match(mut self, new_value: &str) -> BucketPatchCall<'a, C, NC, A> { + pub fn if_metageneration_not_match(mut self, new_value: &str) -> BucketPatchCall<'a, C, A> { self._if_metageneration_not_match = Some(new_value.to_string()); self } @@ -11861,7 +11857,7 @@ impl<'a, C, NC, A> BucketPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Makes the return of the bucket metadata conditional on whether the bucket's current metageneration matches the given value. - pub fn if_metageneration_match(mut self, new_value: &str) -> BucketPatchCall<'a, C, NC, A> { + pub fn if_metageneration_match(mut self, new_value: &str) -> BucketPatchCall<'a, C, A> { self._if_metageneration_match = Some(new_value.to_string()); self } @@ -11872,7 +11868,7 @@ impl<'a, C, NC, A> BucketPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11893,7 +11889,7 @@ impl<'a, C, NC, A> BucketPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BucketPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BucketPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11910,7 +11906,7 @@ impl<'a, C, NC, A> BucketPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BucketPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BucketPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11952,10 +11948,10 @@ impl<'a, C, NC, A> BucketPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct BucketListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BucketListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Storage, + hub: &'a Storage, _project: String, _projection: Option, _prefix: Option, @@ -11966,9 +11962,9 @@ pub struct BucketListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BucketListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BucketListCall<'a, C, A> {} -impl<'a, C, NC, A> BucketListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BucketListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12088,7 +12084,7 @@ impl<'a, C, NC, A> BucketListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// A valid API project identifier. - pub fn project(mut self, new_value: &str) -> BucketListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> BucketListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -12096,7 +12092,7 @@ impl<'a, C, NC, A> BucketListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Set of properties to return. Defaults to noAcl. - pub fn projection(mut self, new_value: &str) -> BucketListCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> BucketListCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -12104,7 +12100,7 @@ impl<'a, C, NC, A> BucketListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Filter results to buckets whose names begin with this prefix. - pub fn prefix(mut self, new_value: &str) -> BucketListCall<'a, C, NC, A> { + pub fn prefix(mut self, new_value: &str) -> BucketListCall<'a, C, A> { self._prefix = Some(new_value.to_string()); self } @@ -12112,7 +12108,7 @@ impl<'a, C, NC, A> BucketListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// A previously-returned page token representing part of the larger set of results to view. - pub fn page_token(mut self, new_value: &str) -> BucketListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> BucketListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -12120,7 +12116,7 @@ impl<'a, C, NC, A> BucketListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Maximum number of buckets to return. - pub fn max_results(mut self, new_value: u32) -> BucketListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> BucketListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -12131,7 +12127,7 @@ impl<'a, C, NC, A> BucketListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BucketListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12152,7 +12148,7 @@ impl<'a, C, NC, A> BucketListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BucketListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BucketListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12169,7 +12165,7 @@ impl<'a, C, NC, A> BucketListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BucketListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BucketListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/tagmanager1/Cargo.toml b/gen/tagmanager1/Cargo.toml index d45ada10c26..b90f2f2aec1 100644 --- a/gen/tagmanager1/Cargo.toml +++ b/gen/tagmanager1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-tagmanager1" -version = "0.1.4+20150121" +version = "0.1.5+20150121" authors = ["Sebastian Thiel "] description = "A complete library to interact with Tag Manager (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/tagmanager1" homepage = "https://developers.google.com/tag-manager/api/v1/" -documentation = "http://byron.github.io/google-apis-rs/google-tagmanager1" +documentation = "http://byron.github.io/google-apis-rs/google_tagmanager1" license = "MIT" keywords = ["tagmanager", "google", "protocol", "web", "api"] diff --git a/gen/tagmanager1/README.md b/gen/tagmanager1/README.md index e248e755a1c..7a40e6ae90f 100644 --- a/gen/tagmanager1/README.md +++ b/gen/tagmanager1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-tagmanager1` library allows access to all features of the *Google Tag Manager* service. -This documentation was generated from *Tag Manager* crate version *0.1.4+20150121*, where *20150121* is the exact revision of the *tagmanager:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *Tag Manager* crate version *0.1.5+20150121*, where *20150121* is the exact revision of the *tagmanager:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *Tag Manager* *v1* API can be found at the [official documentation site](https://developers.google.com/tag-manager/api/v1/). diff --git a/gen/tagmanager1/src/cmn.rs b/gen/tagmanager1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/tagmanager1/src/cmn.rs +++ b/gen/tagmanager1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/tagmanager1/src/lib.rs b/gen/tagmanager1/src/lib.rs index e3067abab50..2f6c756fc77 100644 --- a/gen/tagmanager1/src/lib.rs +++ b/gen/tagmanager1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *Tag Manager* crate version *0.1.4+20150121*, where *20150121* is the exact revision of the *tagmanager:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *Tag Manager* crate version *0.1.5+20150121*, where *20150121* is the exact revision of the *tagmanager:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *Tag Manager* *v1* API can be found at the //! [official documentation site](https://developers.google.com/tag-manager/api/v1/). @@ -240,7 +240,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -362,34 +361,31 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct TagManager { +pub struct TagManager { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for TagManager {} +impl<'a, C, A> Hub for TagManager {} -impl<'a, C, NC, A> TagManager - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TagManager + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> TagManager { + pub fn new(client: C, authenticator: A) -> TagManager { TagManager { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn accounts(&'a self) -> AccountMethods<'a, C, NC, A> { + pub fn accounts(&'a self) -> AccountMethods<'a, C, A> { AccountMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -1259,15 +1255,15 @@ impl Part for Condition {} /// let rb = hub.accounts(); /// # } /// ``` -pub struct AccountMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, } -impl<'a, C, NC, A> MethodsBuilder for AccountMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for AccountMethods<'a, C, A> {} -impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { +impl<'a, C, A> AccountMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1276,7 +1272,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `accountId` - The GTM Account ID. - pub fn containers_list(&self, account_id: &str) -> AccountContainerListCall<'a, C, NC, A> { + pub fn containers_list(&self, account_id: &str) -> AccountContainerListCall<'a, C, A> { AccountContainerListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1293,7 +1289,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `accountId` - The GTM Account ID. @required tagmanager.accounts.permissions.list - pub fn permissions_list(&self, account_id: &str) -> AccountPermissionListCall<'a, C, NC, A> { + pub fn permissions_list(&self, account_id: &str) -> AccountPermissionListCall<'a, C, A> { AccountPermissionListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1312,7 +1308,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. /// * `containerVersionId` - The GTM Container Version ID. - pub fn containers_versions_undelete(&self, account_id: &str, container_id: &str, container_version_id: &str) -> AccountContainerVersionUndeleteCall<'a, C, NC, A> { + pub fn containers_versions_undelete(&self, account_id: &str, container_id: &str, container_version_id: &str) -> AccountContainerVersionUndeleteCall<'a, C, A> { AccountContainerVersionUndeleteCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1332,7 +1328,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `accountId` - The GTM Account ID. - pub fn permissions_create(&self, request: &UserAccess, account_id: &str) -> AccountPermissionCreateCall<'a, C, NC, A> { + pub fn permissions_create(&self, request: &UserAccess, account_id: &str) -> AccountPermissionCreateCall<'a, C, A> { AccountPermissionCreateCall { hub: self.hub, _request: request.clone(), @@ -1351,7 +1347,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `accountId` - The GTM Account ID. /// * `permissionId` - The GTM User ID. - pub fn permissions_delete(&self, account_id: &str, permission_id: &str) -> AccountPermissionDeleteCall<'a, C, NC, A> { + pub fn permissions_delete(&self, account_id: &str, permission_id: &str) -> AccountPermissionDeleteCall<'a, C, A> { AccountPermissionDeleteCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1370,7 +1366,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. - pub fn containers_get(&self, account_id: &str, container_id: &str) -> AccountContainerGetCall<'a, C, NC, A> { + pub fn containers_get(&self, account_id: &str, container_id: &str) -> AccountContainerGetCall<'a, C, A> { AccountContainerGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1389,7 +1385,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. - pub fn containers_versions_list(&self, account_id: &str, container_id: &str) -> AccountContainerVersionListCall<'a, C, NC, A> { + pub fn containers_versions_list(&self, account_id: &str, container_id: &str) -> AccountContainerVersionListCall<'a, C, A> { AccountContainerVersionListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1411,7 +1407,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. /// * `triggerId` - The GTM Trigger ID. - pub fn containers_triggers_update(&self, request: &Trigger, account_id: &str, container_id: &str, trigger_id: &str) -> AccountContainerTriggerUpdateCall<'a, C, NC, A> { + pub fn containers_triggers_update(&self, request: &Trigger, account_id: &str, container_id: &str, trigger_id: &str) -> AccountContainerTriggerUpdateCall<'a, C, A> { AccountContainerTriggerUpdateCall { hub: self.hub, _request: request.clone(), @@ -1434,7 +1430,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. /// * `triggerId` - The GTM Trigger ID. - pub fn containers_triggers_get(&self, account_id: &str, container_id: &str, trigger_id: &str) -> AccountContainerTriggerGetCall<'a, C, NC, A> { + pub fn containers_triggers_get(&self, account_id: &str, container_id: &str, trigger_id: &str) -> AccountContainerTriggerGetCall<'a, C, A> { AccountContainerTriggerGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1454,7 +1450,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. - pub fn containers_delete(&self, account_id: &str, container_id: &str) -> AccountContainerDeleteCall<'a, C, NC, A> { + pub fn containers_delete(&self, account_id: &str, container_id: &str) -> AccountContainerDeleteCall<'a, C, A> { AccountContainerDeleteCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1473,7 +1469,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `accountId` - The GTM Account ID. - pub fn containers_create(&self, request: &Container, account_id: &str) -> AccountContainerCreateCall<'a, C, NC, A> { + pub fn containers_create(&self, request: &Container, account_id: &str) -> AccountContainerCreateCall<'a, C, A> { AccountContainerCreateCall { hub: self.hub, _request: request.clone(), @@ -1493,7 +1489,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. /// * `tagId` - The GTM Tag ID. - pub fn containers_tags_delete(&self, account_id: &str, container_id: &str, tag_id: &str) -> AccountContainerTagDeleteCall<'a, C, NC, A> { + pub fn containers_tags_delete(&self, account_id: &str, container_id: &str, tag_id: &str) -> AccountContainerTagDeleteCall<'a, C, A> { AccountContainerTagDeleteCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1515,7 +1511,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. /// * `ruleId` - The GTM Rule ID. - pub fn containers_rules_update(&self, request: &Rule, account_id: &str, container_id: &str, rule_id: &str) -> AccountContainerRuleUpdateCall<'a, C, NC, A> { + pub fn containers_rules_update(&self, request: &Rule, account_id: &str, container_id: &str, rule_id: &str) -> AccountContainerRuleUpdateCall<'a, C, A> { AccountContainerRuleUpdateCall { hub: self.hub, _request: request.clone(), @@ -1538,7 +1534,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. /// * `ruleId` - The GTM Rule ID. - pub fn containers_rules_delete(&self, account_id: &str, container_id: &str, rule_id: &str) -> AccountContainerRuleDeleteCall<'a, C, NC, A> { + pub fn containers_rules_delete(&self, account_id: &str, container_id: &str, rule_id: &str) -> AccountContainerRuleDeleteCall<'a, C, A> { AccountContainerRuleDeleteCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1558,7 +1554,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. - pub fn containers_tags_list(&self, account_id: &str, container_id: &str) -> AccountContainerTagListCall<'a, C, NC, A> { + pub fn containers_tags_list(&self, account_id: &str, container_id: &str) -> AccountContainerTagListCall<'a, C, A> { AccountContainerTagListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1578,7 +1574,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. /// * `containerVersionId` - The GTM Container Version ID. - pub fn containers_versions_publish(&self, account_id: &str, container_id: &str, container_version_id: &str) -> AccountContainerVersionPublishCall<'a, C, NC, A> { + pub fn containers_versions_publish(&self, account_id: &str, container_id: &str, container_version_id: &str) -> AccountContainerVersionPublishCall<'a, C, A> { AccountContainerVersionPublishCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1600,7 +1596,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. - pub fn containers_tags_create(&self, request: &Tag, account_id: &str, container_id: &str) -> AccountContainerTagCreateCall<'a, C, NC, A> { + pub fn containers_tags_create(&self, request: &Tag, account_id: &str, container_id: &str) -> AccountContainerTagCreateCall<'a, C, A> { AccountContainerTagCreateCall { hub: self.hub, _request: request.clone(), @@ -1620,7 +1616,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. - pub fn containers_triggers_list(&self, account_id: &str, container_id: &str) -> AccountContainerTriggerListCall<'a, C, NC, A> { + pub fn containers_triggers_list(&self, account_id: &str, container_id: &str) -> AccountContainerTriggerListCall<'a, C, A> { AccountContainerTriggerListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1640,7 +1636,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. /// * `containerVersionId` - The GTM Container Version ID. - pub fn containers_versions_delete(&self, account_id: &str, container_id: &str, container_version_id: &str) -> AccountContainerVersionDeleteCall<'a, C, NC, A> { + pub fn containers_versions_delete(&self, account_id: &str, container_id: &str, container_version_id: &str) -> AccountContainerVersionDeleteCall<'a, C, A> { AccountContainerVersionDeleteCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1660,7 +1656,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `accountId` - The GTM Account ID. - pub fn update(&self, request: &Account, account_id: &str) -> AccountUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Account, account_id: &str) -> AccountUpdateCall<'a, C, A> { AccountUpdateCall { hub: self.hub, _request: request.clone(), @@ -1681,7 +1677,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. /// * `macroId` - The GTM Macro ID. - pub fn containers_macros_delete(&self, account_id: &str, container_id: &str, macro_id: &str) -> AccountContainerMacroDeleteCall<'a, C, NC, A> { + pub fn containers_macros_delete(&self, account_id: &str, container_id: &str, macro_id: &str) -> AccountContainerMacroDeleteCall<'a, C, A> { AccountContainerMacroDeleteCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1702,7 +1698,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. - pub fn containers_versions_create(&self, request: &CreateContainerVersionRequestVersionOptions, account_id: &str, container_id: &str) -> AccountContainerVersionCreateCall<'a, C, NC, A> { + pub fn containers_versions_create(&self, request: &CreateContainerVersionRequestVersionOptions, account_id: &str, container_id: &str) -> AccountContainerVersionCreateCall<'a, C, A> { AccountContainerVersionCreateCall { hub: self.hub, _request: request.clone(), @@ -1722,7 +1718,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `accountId` - The GTM Account ID. /// * `permissionId` - The GTM User ID. - pub fn permissions_get(&self, account_id: &str, permission_id: &str) -> AccountPermissionGetCall<'a, C, NC, A> { + pub fn permissions_get(&self, account_id: &str, permission_id: &str) -> AccountPermissionGetCall<'a, C, A> { AccountPermissionGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1742,7 +1738,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. - pub fn containers_rules_create(&self, request: &Rule, account_id: &str, container_id: &str) -> AccountContainerRuleCreateCall<'a, C, NC, A> { + pub fn containers_rules_create(&self, request: &Rule, account_id: &str, container_id: &str) -> AccountContainerRuleCreateCall<'a, C, A> { AccountContainerRuleCreateCall { hub: self.hub, _request: request.clone(), @@ -1763,7 +1759,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. /// * `containerVersionId` - The GTM Container Version ID. - pub fn containers_versions_restore(&self, account_id: &str, container_id: &str, container_version_id: &str) -> AccountContainerVersionRestoreCall<'a, C, NC, A> { + pub fn containers_versions_restore(&self, account_id: &str, container_id: &str, container_version_id: &str) -> AccountContainerVersionRestoreCall<'a, C, A> { AccountContainerVersionRestoreCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1784,7 +1780,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. /// * `ruleId` - The GTM Rule ID. - pub fn containers_rules_get(&self, account_id: &str, container_id: &str, rule_id: &str) -> AccountContainerRuleGetCall<'a, C, NC, A> { + pub fn containers_rules_get(&self, account_id: &str, container_id: &str, rule_id: &str) -> AccountContainerRuleGetCall<'a, C, A> { AccountContainerRuleGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1805,7 +1801,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. - pub fn containers_variables_create(&self, request: &Variable, account_id: &str, container_id: &str) -> AccountContainerVariableCreateCall<'a, C, NC, A> { + pub fn containers_variables_create(&self, request: &Variable, account_id: &str, container_id: &str) -> AccountContainerVariableCreateCall<'a, C, A> { AccountContainerVariableCreateCall { hub: self.hub, _request: request.clone(), @@ -1825,7 +1821,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. - pub fn containers_variables_list(&self, account_id: &str, container_id: &str) -> AccountContainerVariableListCall<'a, C, NC, A> { + pub fn containers_variables_list(&self, account_id: &str, container_id: &str) -> AccountContainerVariableListCall<'a, C, A> { AccountContainerVariableListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1845,7 +1841,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. - pub fn containers_macros_create(&self, request: &Macro, account_id: &str, container_id: &str) -> AccountContainerMacroCreateCall<'a, C, NC, A> { + pub fn containers_macros_create(&self, request: &Macro, account_id: &str, container_id: &str) -> AccountContainerMacroCreateCall<'a, C, A> { AccountContainerMacroCreateCall { hub: self.hub, _request: request.clone(), @@ -1866,7 +1862,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. /// * `tagId` - The GTM Tag ID. - pub fn containers_tags_get(&self, account_id: &str, container_id: &str, tag_id: &str) -> AccountContainerTagGetCall<'a, C, NC, A> { + pub fn containers_tags_get(&self, account_id: &str, container_id: &str, tag_id: &str) -> AccountContainerTagGetCall<'a, C, A> { AccountContainerTagGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1887,7 +1883,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. /// * `variableId` - The GTM Variable ID. - pub fn containers_variables_get(&self, account_id: &str, container_id: &str, variable_id: &str) -> AccountContainerVariableGetCall<'a, C, NC, A> { + pub fn containers_variables_get(&self, account_id: &str, container_id: &str, variable_id: &str) -> AccountContainerVariableGetCall<'a, C, A> { AccountContainerVariableGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1908,7 +1904,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. /// * `triggerId` - The GTM Trigger ID. - pub fn containers_triggers_delete(&self, account_id: &str, container_id: &str, trigger_id: &str) -> AccountContainerTriggerDeleteCall<'a, C, NC, A> { + pub fn containers_triggers_delete(&self, account_id: &str, container_id: &str, trigger_id: &str) -> AccountContainerTriggerDeleteCall<'a, C, A> { AccountContainerTriggerDeleteCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1928,7 +1924,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. - pub fn containers_macros_list(&self, account_id: &str, container_id: &str) -> AccountContainerMacroListCall<'a, C, NC, A> { + pub fn containers_macros_list(&self, account_id: &str, container_id: &str) -> AccountContainerMacroListCall<'a, C, A> { AccountContainerMacroListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -1948,7 +1944,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. - pub fn containers_triggers_create(&self, request: &Trigger, account_id: &str, container_id: &str) -> AccountContainerTriggerCreateCall<'a, C, NC, A> { + pub fn containers_triggers_create(&self, request: &Trigger, account_id: &str, container_id: &str) -> AccountContainerTriggerCreateCall<'a, C, A> { AccountContainerTriggerCreateCall { hub: self.hub, _request: request.clone(), @@ -1970,7 +1966,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. /// * `macroId` - The GTM Macro ID. - pub fn containers_macros_update(&self, request: &Macro, account_id: &str, container_id: &str, macro_id: &str) -> AccountContainerMacroUpdateCall<'a, C, NC, A> { + pub fn containers_macros_update(&self, request: &Macro, account_id: &str, container_id: &str, macro_id: &str) -> AccountContainerMacroUpdateCall<'a, C, A> { AccountContainerMacroUpdateCall { hub: self.hub, _request: request.clone(), @@ -1987,7 +1983,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Lists all GTM Accounts that a user has access to. - pub fn list(&self) -> AccountListCall<'a, C, NC, A> { + pub fn list(&self) -> AccountListCall<'a, C, A> { AccountListCall { hub: self.hub, _delegate: Default::default(), @@ -2005,7 +2001,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - The GTM Account ID. /// * `permissionId` - The GTM User ID. - pub fn permissions_update(&self, request: &UserAccess, account_id: &str, permission_id: &str) -> AccountPermissionUpdateCall<'a, C, NC, A> { + pub fn permissions_update(&self, request: &UserAccess, account_id: &str, permission_id: &str) -> AccountPermissionUpdateCall<'a, C, A> { AccountPermissionUpdateCall { hub: self.hub, _request: request.clone(), @@ -2026,7 +2022,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. /// * `variableId` - The GTM Variable ID. - pub fn containers_variables_delete(&self, account_id: &str, container_id: &str, variable_id: &str) -> AccountContainerVariableDeleteCall<'a, C, NC, A> { + pub fn containers_variables_delete(&self, account_id: &str, container_id: &str, variable_id: &str) -> AccountContainerVariableDeleteCall<'a, C, A> { AccountContainerVariableDeleteCall { hub: self.hub, _account_id: account_id.to_string(), @@ -2045,7 +2041,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// # Arguments /// /// * `accountId` - The GTM Account ID. - pub fn get(&self, account_id: &str) -> AccountGetCall<'a, C, NC, A> { + pub fn get(&self, account_id: &str) -> AccountGetCall<'a, C, A> { AccountGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -2064,7 +2060,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. - pub fn containers_update(&self, request: &Container, account_id: &str, container_id: &str) -> AccountContainerUpdateCall<'a, C, NC, A> { + pub fn containers_update(&self, request: &Container, account_id: &str, container_id: &str) -> AccountContainerUpdateCall<'a, C, A> { AccountContainerUpdateCall { hub: self.hub, _request: request.clone(), @@ -2085,7 +2081,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. - pub fn containers_rules_list(&self, account_id: &str, container_id: &str) -> AccountContainerRuleListCall<'a, C, NC, A> { + pub fn containers_rules_list(&self, account_id: &str, container_id: &str) -> AccountContainerRuleListCall<'a, C, A> { AccountContainerRuleListCall { hub: self.hub, _account_id: account_id.to_string(), @@ -2106,7 +2102,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. /// * `tagId` - The GTM Tag ID. - pub fn containers_tags_update(&self, request: &Tag, account_id: &str, container_id: &str, tag_id: &str) -> AccountContainerTagUpdateCall<'a, C, NC, A> { + pub fn containers_tags_update(&self, request: &Tag, account_id: &str, container_id: &str, tag_id: &str) -> AccountContainerTagUpdateCall<'a, C, A> { AccountContainerTagUpdateCall { hub: self.hub, _request: request.clone(), @@ -2129,7 +2125,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. /// * `macroId` - The GTM Macro ID. - pub fn containers_macros_get(&self, account_id: &str, container_id: &str, macro_id: &str) -> AccountContainerMacroGetCall<'a, C, NC, A> { + pub fn containers_macros_get(&self, account_id: &str, container_id: &str, macro_id: &str) -> AccountContainerMacroGetCall<'a, C, A> { AccountContainerMacroGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -2151,7 +2147,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. /// * `containerVersionId` - The GTM Container Version ID. - pub fn containers_versions_update(&self, request: &ContainerVersion, account_id: &str, container_id: &str, container_version_id: &str) -> AccountContainerVersionUpdateCall<'a, C, NC, A> { + pub fn containers_versions_update(&self, request: &ContainerVersion, account_id: &str, container_id: &str, container_version_id: &str) -> AccountContainerVersionUpdateCall<'a, C, A> { AccountContainerVersionUpdateCall { hub: self.hub, _request: request.clone(), @@ -2175,7 +2171,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. /// * `variableId` - The GTM Variable ID. - pub fn containers_variables_update(&self, request: &Variable, account_id: &str, container_id: &str, variable_id: &str) -> AccountContainerVariableUpdateCall<'a, C, NC, A> { + pub fn containers_variables_update(&self, request: &Variable, account_id: &str, container_id: &str, variable_id: &str) -> AccountContainerVariableUpdateCall<'a, C, A> { AccountContainerVariableUpdateCall { hub: self.hub, _request: request.clone(), @@ -2198,7 +2194,7 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// * `accountId` - The GTM Account ID. /// * `containerId` - The GTM Container ID. /// * `containerVersionId` - The GTM Container Version ID. Specify published to retrieve the currently published version. - pub fn containers_versions_get(&self, account_id: &str, container_id: &str, container_version_id: &str) -> AccountContainerVersionGetCall<'a, C, NC, A> { + pub fn containers_versions_get(&self, account_id: &str, container_id: &str, container_version_id: &str) -> AccountContainerVersionGetCall<'a, C, A> { AccountContainerVersionGetCall { hub: self.hub, _account_id: account_id.to_string(), @@ -2249,19 +2245,19 @@ impl<'a, C, NC, A> AccountMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct AccountContainerListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2393,7 +2389,7 @@ impl<'a, C, NC, A> AccountContainerListCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -2404,7 +2400,7 @@ impl<'a, C, NC, A> AccountContainerListCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2425,7 +2421,7 @@ impl<'a, C, NC, A> AccountContainerListCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2442,7 +2438,7 @@ impl<'a, C, NC, A> AccountContainerListCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2480,19 +2476,19 @@ impl<'a, C, NC, A> AccountContainerListCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct AccountPermissionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountPermissionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountPermissionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountPermissionListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountPermissionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountPermissionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2624,7 +2620,7 @@ impl<'a, C, NC, A> AccountPermissionListCall<'a, C, NC, A> where NC: hyper::net: /// we provide this method for API completeness. /// /// The GTM Account ID. @required tagmanager.accounts.permissions.list - pub fn account_id(mut self, new_value: &str) -> AccountPermissionListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountPermissionListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -2635,7 +2631,7 @@ impl<'a, C, NC, A> AccountPermissionListCall<'a, C, NC, A> where NC: hyper::net: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPermissionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPermissionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2656,7 +2652,7 @@ impl<'a, C, NC, A> AccountPermissionListCall<'a, C, NC, A> where NC: hyper::net: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountPermissionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountPermissionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2673,7 +2669,7 @@ impl<'a, C, NC, A> AccountPermissionListCall<'a, C, NC, A> where NC: hyper::net: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountPermissionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountPermissionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2711,10 +2707,10 @@ impl<'a, C, NC, A> AccountPermissionListCall<'a, C, NC, A> where NC: hyper::net: /// .doit(); /// # } /// ``` -pub struct AccountContainerVersionUndeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerVersionUndeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _container_id: String, _container_version_id: String, @@ -2723,9 +2719,9 @@ pub struct AccountContainerVersionUndeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerVersionUndeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerVersionUndeleteCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerVersionUndeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerVersionUndeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2859,7 +2855,7 @@ impl<'a, C, NC, A> AccountContainerVersionUndeleteCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerVersionUndeleteCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerVersionUndeleteCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -2869,7 +2865,7 @@ impl<'a, C, NC, A> AccountContainerVersionUndeleteCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerVersionUndeleteCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerVersionUndeleteCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -2879,7 +2875,7 @@ impl<'a, C, NC, A> AccountContainerVersionUndeleteCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// The GTM Container Version ID. - pub fn container_version_id(mut self, new_value: &str) -> AccountContainerVersionUndeleteCall<'a, C, NC, A> { + pub fn container_version_id(mut self, new_value: &str) -> AccountContainerVersionUndeleteCall<'a, C, A> { self._container_version_id = new_value.to_string(); self } @@ -2890,7 +2886,7 @@ impl<'a, C, NC, A> AccountContainerVersionUndeleteCall<'a, C, NC, A> where NC: h /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVersionUndeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVersionUndeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2911,7 +2907,7 @@ impl<'a, C, NC, A> AccountContainerVersionUndeleteCall<'a, C, NC, A> where NC: h /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerVersionUndeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerVersionUndeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2928,7 +2924,7 @@ impl<'a, C, NC, A> AccountContainerVersionUndeleteCall<'a, C, NC, A> where NC: h /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerVersionUndeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerVersionUndeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2972,10 +2968,10 @@ impl<'a, C, NC, A> AccountContainerVersionUndeleteCall<'a, C, NC, A> where NC: h /// .doit(); /// # } /// ``` -pub struct AccountPermissionCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountPermissionCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _request: UserAccess, _account_id: String, _delegate: Option<&'a mut Delegate>, @@ -2983,9 +2979,9 @@ pub struct AccountPermissionCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountPermissionCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountPermissionCreateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountPermissionCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountPermissionCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3124,7 +3120,7 @@ impl<'a, C, NC, A> AccountPermissionCreateCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &UserAccess) -> AccountPermissionCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &UserAccess) -> AccountPermissionCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3134,7 +3130,7 @@ impl<'a, C, NC, A> AccountPermissionCreateCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountPermissionCreateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountPermissionCreateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -3145,7 +3141,7 @@ impl<'a, C, NC, A> AccountPermissionCreateCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPermissionCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPermissionCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3166,7 +3162,7 @@ impl<'a, C, NC, A> AccountPermissionCreateCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountPermissionCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountPermissionCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3183,7 +3179,7 @@ impl<'a, C, NC, A> AccountPermissionCreateCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountPermissionCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountPermissionCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3221,10 +3217,10 @@ impl<'a, C, NC, A> AccountPermissionCreateCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct AccountPermissionDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountPermissionDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _permission_id: String, _delegate: Option<&'a mut Delegate>, @@ -3232,9 +3228,9 @@ pub struct AccountPermissionDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountPermissionDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountPermissionDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> AccountPermissionDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountPermissionDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3356,7 +3352,7 @@ impl<'a, C, NC, A> AccountPermissionDeleteCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountPermissionDeleteCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountPermissionDeleteCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -3366,7 +3362,7 @@ impl<'a, C, NC, A> AccountPermissionDeleteCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The GTM User ID. - pub fn permission_id(mut self, new_value: &str) -> AccountPermissionDeleteCall<'a, C, NC, A> { + pub fn permission_id(mut self, new_value: &str) -> AccountPermissionDeleteCall<'a, C, A> { self._permission_id = new_value.to_string(); self } @@ -3377,7 +3373,7 @@ impl<'a, C, NC, A> AccountPermissionDeleteCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPermissionDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPermissionDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3398,7 +3394,7 @@ impl<'a, C, NC, A> AccountPermissionDeleteCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountPermissionDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountPermissionDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3415,7 +3411,7 @@ impl<'a, C, NC, A> AccountPermissionDeleteCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountPermissionDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountPermissionDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3453,10 +3449,10 @@ impl<'a, C, NC, A> AccountPermissionDeleteCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct AccountContainerGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _container_id: String, _delegate: Option<&'a mut Delegate>, @@ -3464,9 +3460,9 @@ pub struct AccountContainerGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3599,7 +3595,7 @@ impl<'a, C, NC, A> AccountContainerGetCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -3609,7 +3605,7 @@ impl<'a, C, NC, A> AccountContainerGetCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerGetCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerGetCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -3620,7 +3616,7 @@ impl<'a, C, NC, A> AccountContainerGetCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3641,7 +3637,7 @@ impl<'a, C, NC, A> AccountContainerGetCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3658,7 +3654,7 @@ impl<'a, C, NC, A> AccountContainerGetCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3697,10 +3693,10 @@ impl<'a, C, NC, A> AccountContainerGetCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct AccountContainerVersionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerVersionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _container_id: String, _headers: Option, @@ -3709,9 +3705,9 @@ pub struct AccountContainerVersionListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerVersionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerVersionListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerVersionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerVersionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3847,7 +3843,7 @@ impl<'a, C, NC, A> AccountContainerVersionListCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerVersionListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerVersionListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -3857,7 +3853,7 @@ impl<'a, C, NC, A> AccountContainerVersionListCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerVersionListCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerVersionListCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -3865,7 +3861,7 @@ impl<'a, C, NC, A> AccountContainerVersionListCall<'a, C, NC, A> where NC: hyper /// /// /// Retrieve headers only when true. - pub fn headers(mut self, new_value: bool) -> AccountContainerVersionListCall<'a, C, NC, A> { + pub fn headers(mut self, new_value: bool) -> AccountContainerVersionListCall<'a, C, A> { self._headers = Some(new_value); self } @@ -3876,7 +3872,7 @@ impl<'a, C, NC, A> AccountContainerVersionListCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVersionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVersionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3897,7 +3893,7 @@ impl<'a, C, NC, A> AccountContainerVersionListCall<'a, C, NC, A> where NC: hyper /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerVersionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerVersionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3914,7 +3910,7 @@ impl<'a, C, NC, A> AccountContainerVersionListCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerVersionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerVersionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3959,10 +3955,10 @@ impl<'a, C, NC, A> AccountContainerVersionListCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct AccountContainerTriggerUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerTriggerUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _request: Trigger, _account_id: String, _container_id: String, @@ -3973,9 +3969,9 @@ pub struct AccountContainerTriggerUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerTriggerUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerTriggerUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerTriggerUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerTriggerUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4119,7 +4115,7 @@ impl<'a, C, NC, A> AccountContainerTriggerUpdateCall<'a, C, NC, A> where NC: hyp /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Trigger) -> AccountContainerTriggerUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Trigger) -> AccountContainerTriggerUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4129,7 +4125,7 @@ impl<'a, C, NC, A> AccountContainerTriggerUpdateCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerTriggerUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerTriggerUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -4139,7 +4135,7 @@ impl<'a, C, NC, A> AccountContainerTriggerUpdateCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerTriggerUpdateCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerTriggerUpdateCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -4149,7 +4145,7 @@ impl<'a, C, NC, A> AccountContainerTriggerUpdateCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// The GTM Trigger ID. - pub fn trigger_id(mut self, new_value: &str) -> AccountContainerTriggerUpdateCall<'a, C, NC, A> { + pub fn trigger_id(mut self, new_value: &str) -> AccountContainerTriggerUpdateCall<'a, C, A> { self._trigger_id = new_value.to_string(); self } @@ -4157,7 +4153,7 @@ impl<'a, C, NC, A> AccountContainerTriggerUpdateCall<'a, C, NC, A> where NC: hyp /// /// /// When provided, this fingerprint must match the fingerprint of the trigger in storage. - pub fn fingerprint(mut self, new_value: &str) -> AccountContainerTriggerUpdateCall<'a, C, NC, A> { + pub fn fingerprint(mut self, new_value: &str) -> AccountContainerTriggerUpdateCall<'a, C, A> { self._fingerprint = Some(new_value.to_string()); self } @@ -4168,7 +4164,7 @@ impl<'a, C, NC, A> AccountContainerTriggerUpdateCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerTriggerUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerTriggerUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4189,7 +4185,7 @@ impl<'a, C, NC, A> AccountContainerTriggerUpdateCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerTriggerUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerTriggerUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4206,7 +4202,7 @@ impl<'a, C, NC, A> AccountContainerTriggerUpdateCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerTriggerUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerTriggerUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4244,10 +4240,10 @@ impl<'a, C, NC, A> AccountContainerTriggerUpdateCall<'a, C, NC, A> where NC: hyp /// .doit(); /// # } /// ``` -pub struct AccountContainerTriggerGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerTriggerGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _container_id: String, _trigger_id: String, @@ -4256,9 +4252,9 @@ pub struct AccountContainerTriggerGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerTriggerGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerTriggerGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerTriggerGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerTriggerGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4392,7 +4388,7 @@ impl<'a, C, NC, A> AccountContainerTriggerGetCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerTriggerGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerTriggerGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -4402,7 +4398,7 @@ impl<'a, C, NC, A> AccountContainerTriggerGetCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerTriggerGetCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerTriggerGetCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -4412,7 +4408,7 @@ impl<'a, C, NC, A> AccountContainerTriggerGetCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The GTM Trigger ID. - pub fn trigger_id(mut self, new_value: &str) -> AccountContainerTriggerGetCall<'a, C, NC, A> { + pub fn trigger_id(mut self, new_value: &str) -> AccountContainerTriggerGetCall<'a, C, A> { self._trigger_id = new_value.to_string(); self } @@ -4423,7 +4419,7 @@ impl<'a, C, NC, A> AccountContainerTriggerGetCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerTriggerGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerTriggerGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4444,7 +4440,7 @@ impl<'a, C, NC, A> AccountContainerTriggerGetCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerTriggerGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerTriggerGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4461,7 +4457,7 @@ impl<'a, C, NC, A> AccountContainerTriggerGetCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerTriggerGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerTriggerGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4499,10 +4495,10 @@ impl<'a, C, NC, A> AccountContainerTriggerGetCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct AccountContainerDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _container_id: String, _delegate: Option<&'a mut Delegate>, @@ -4510,9 +4506,9 @@ pub struct AccountContainerDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4634,7 +4630,7 @@ impl<'a, C, NC, A> AccountContainerDeleteCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerDeleteCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerDeleteCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -4644,7 +4640,7 @@ impl<'a, C, NC, A> AccountContainerDeleteCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerDeleteCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerDeleteCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -4655,7 +4651,7 @@ impl<'a, C, NC, A> AccountContainerDeleteCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4676,7 +4672,7 @@ impl<'a, C, NC, A> AccountContainerDeleteCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4693,7 +4689,7 @@ impl<'a, C, NC, A> AccountContainerDeleteCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4737,10 +4733,10 @@ impl<'a, C, NC, A> AccountContainerDeleteCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct AccountContainerCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _request: Container, _account_id: String, _delegate: Option<&'a mut Delegate>, @@ -4748,9 +4744,9 @@ pub struct AccountContainerCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerCreateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4889,7 +4885,7 @@ impl<'a, C, NC, A> AccountContainerCreateCall<'a, C, NC, A> where NC: hyper::net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Container) -> AccountContainerCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Container) -> AccountContainerCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4899,7 +4895,7 @@ impl<'a, C, NC, A> AccountContainerCreateCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerCreateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerCreateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -4910,7 +4906,7 @@ impl<'a, C, NC, A> AccountContainerCreateCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4931,7 +4927,7 @@ impl<'a, C, NC, A> AccountContainerCreateCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4948,7 +4944,7 @@ impl<'a, C, NC, A> AccountContainerCreateCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4986,10 +4982,10 @@ impl<'a, C, NC, A> AccountContainerCreateCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct AccountContainerTagDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerTagDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _container_id: String, _tag_id: String, @@ -4998,9 +4994,9 @@ pub struct AccountContainerTagDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerTagDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerTagDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerTagDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerTagDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5123,7 +5119,7 @@ impl<'a, C, NC, A> AccountContainerTagDeleteCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerTagDeleteCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerTagDeleteCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -5133,7 +5129,7 @@ impl<'a, C, NC, A> AccountContainerTagDeleteCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerTagDeleteCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerTagDeleteCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -5143,7 +5139,7 @@ impl<'a, C, NC, A> AccountContainerTagDeleteCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The GTM Tag ID. - pub fn tag_id(mut self, new_value: &str) -> AccountContainerTagDeleteCall<'a, C, NC, A> { + pub fn tag_id(mut self, new_value: &str) -> AccountContainerTagDeleteCall<'a, C, A> { self._tag_id = new_value.to_string(); self } @@ -5154,7 +5150,7 @@ impl<'a, C, NC, A> AccountContainerTagDeleteCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerTagDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerTagDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5175,7 +5171,7 @@ impl<'a, C, NC, A> AccountContainerTagDeleteCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerTagDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerTagDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5192,7 +5188,7 @@ impl<'a, C, NC, A> AccountContainerTagDeleteCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerTagDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerTagDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5237,10 +5233,10 @@ impl<'a, C, NC, A> AccountContainerTagDeleteCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct AccountContainerRuleUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerRuleUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _request: Rule, _account_id: String, _container_id: String, @@ -5251,9 +5247,9 @@ pub struct AccountContainerRuleUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerRuleUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerRuleUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerRuleUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerRuleUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5397,7 +5393,7 @@ impl<'a, C, NC, A> AccountContainerRuleUpdateCall<'a, C, NC, A> where NC: hyper: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Rule) -> AccountContainerRuleUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Rule) -> AccountContainerRuleUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -5407,7 +5403,7 @@ impl<'a, C, NC, A> AccountContainerRuleUpdateCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerRuleUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerRuleUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -5417,7 +5413,7 @@ impl<'a, C, NC, A> AccountContainerRuleUpdateCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerRuleUpdateCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerRuleUpdateCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -5427,7 +5423,7 @@ impl<'a, C, NC, A> AccountContainerRuleUpdateCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The GTM Rule ID. - pub fn rule_id(mut self, new_value: &str) -> AccountContainerRuleUpdateCall<'a, C, NC, A> { + pub fn rule_id(mut self, new_value: &str) -> AccountContainerRuleUpdateCall<'a, C, A> { self._rule_id = new_value.to_string(); self } @@ -5435,7 +5431,7 @@ impl<'a, C, NC, A> AccountContainerRuleUpdateCall<'a, C, NC, A> where NC: hyper: /// /// /// When provided, this fingerprint must match the fingerprint of the rule in storage. - pub fn fingerprint(mut self, new_value: &str) -> AccountContainerRuleUpdateCall<'a, C, NC, A> { + pub fn fingerprint(mut self, new_value: &str) -> AccountContainerRuleUpdateCall<'a, C, A> { self._fingerprint = Some(new_value.to_string()); self } @@ -5446,7 +5442,7 @@ impl<'a, C, NC, A> AccountContainerRuleUpdateCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerRuleUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerRuleUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5467,7 +5463,7 @@ impl<'a, C, NC, A> AccountContainerRuleUpdateCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerRuleUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerRuleUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5484,7 +5480,7 @@ impl<'a, C, NC, A> AccountContainerRuleUpdateCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerRuleUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerRuleUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5522,10 +5518,10 @@ impl<'a, C, NC, A> AccountContainerRuleUpdateCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct AccountContainerRuleDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerRuleDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _container_id: String, _rule_id: String, @@ -5534,9 +5530,9 @@ pub struct AccountContainerRuleDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerRuleDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerRuleDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerRuleDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerRuleDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5659,7 +5655,7 @@ impl<'a, C, NC, A> AccountContainerRuleDeleteCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerRuleDeleteCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerRuleDeleteCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -5669,7 +5665,7 @@ impl<'a, C, NC, A> AccountContainerRuleDeleteCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerRuleDeleteCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerRuleDeleteCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -5679,7 +5675,7 @@ impl<'a, C, NC, A> AccountContainerRuleDeleteCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The GTM Rule ID. - pub fn rule_id(mut self, new_value: &str) -> AccountContainerRuleDeleteCall<'a, C, NC, A> { + pub fn rule_id(mut self, new_value: &str) -> AccountContainerRuleDeleteCall<'a, C, A> { self._rule_id = new_value.to_string(); self } @@ -5690,7 +5686,7 @@ impl<'a, C, NC, A> AccountContainerRuleDeleteCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerRuleDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerRuleDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5711,7 +5707,7 @@ impl<'a, C, NC, A> AccountContainerRuleDeleteCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerRuleDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerRuleDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5728,7 +5724,7 @@ impl<'a, C, NC, A> AccountContainerRuleDeleteCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerRuleDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerRuleDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -5766,10 +5762,10 @@ impl<'a, C, NC, A> AccountContainerRuleDeleteCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct AccountContainerTagListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerTagListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _container_id: String, _delegate: Option<&'a mut Delegate>, @@ -5777,9 +5773,9 @@ pub struct AccountContainerTagListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerTagListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerTagListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerTagListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerTagListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -5912,7 +5908,7 @@ impl<'a, C, NC, A> AccountContainerTagListCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerTagListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerTagListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -5922,7 +5918,7 @@ impl<'a, C, NC, A> AccountContainerTagListCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerTagListCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerTagListCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -5933,7 +5929,7 @@ impl<'a, C, NC, A> AccountContainerTagListCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerTagListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerTagListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -5954,7 +5950,7 @@ impl<'a, C, NC, A> AccountContainerTagListCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerTagListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerTagListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -5971,7 +5967,7 @@ impl<'a, C, NC, A> AccountContainerTagListCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerTagListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerTagListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6010,10 +6006,10 @@ impl<'a, C, NC, A> AccountContainerTagListCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct AccountContainerVersionPublishCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerVersionPublishCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _container_id: String, _container_version_id: String, @@ -6023,9 +6019,9 @@ pub struct AccountContainerVersionPublishCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerVersionPublishCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerVersionPublishCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerVersionPublishCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerVersionPublishCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6162,7 +6158,7 @@ impl<'a, C, NC, A> AccountContainerVersionPublishCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerVersionPublishCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerVersionPublishCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -6172,7 +6168,7 @@ impl<'a, C, NC, A> AccountContainerVersionPublishCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerVersionPublishCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerVersionPublishCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -6182,7 +6178,7 @@ impl<'a, C, NC, A> AccountContainerVersionPublishCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// The GTM Container Version ID. - pub fn container_version_id(mut self, new_value: &str) -> AccountContainerVersionPublishCall<'a, C, NC, A> { + pub fn container_version_id(mut self, new_value: &str) -> AccountContainerVersionPublishCall<'a, C, A> { self._container_version_id = new_value.to_string(); self } @@ -6190,7 +6186,7 @@ impl<'a, C, NC, A> AccountContainerVersionPublishCall<'a, C, NC, A> where NC: hy /// /// /// When provided, this fingerprint must match the fingerprint of the container version in storage. - pub fn fingerprint(mut self, new_value: &str) -> AccountContainerVersionPublishCall<'a, C, NC, A> { + pub fn fingerprint(mut self, new_value: &str) -> AccountContainerVersionPublishCall<'a, C, A> { self._fingerprint = Some(new_value.to_string()); self } @@ -6201,7 +6197,7 @@ impl<'a, C, NC, A> AccountContainerVersionPublishCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVersionPublishCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVersionPublishCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6222,7 +6218,7 @@ impl<'a, C, NC, A> AccountContainerVersionPublishCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerVersionPublishCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerVersionPublishCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6239,7 +6235,7 @@ impl<'a, C, NC, A> AccountContainerVersionPublishCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerVersionPublishCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerVersionPublishCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6283,10 +6279,10 @@ impl<'a, C, NC, A> AccountContainerVersionPublishCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct AccountContainerTagCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerTagCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _request: Tag, _account_id: String, _container_id: String, @@ -6295,9 +6291,9 @@ pub struct AccountContainerTagCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerTagCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerTagCreateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerTagCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerTagCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6437,7 +6433,7 @@ impl<'a, C, NC, A> AccountContainerTagCreateCall<'a, C, NC, A> where NC: hyper:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Tag) -> AccountContainerTagCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Tag) -> AccountContainerTagCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6447,7 +6443,7 @@ impl<'a, C, NC, A> AccountContainerTagCreateCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerTagCreateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerTagCreateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -6457,7 +6453,7 @@ impl<'a, C, NC, A> AccountContainerTagCreateCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerTagCreateCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerTagCreateCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -6468,7 +6464,7 @@ impl<'a, C, NC, A> AccountContainerTagCreateCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerTagCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerTagCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6489,7 +6485,7 @@ impl<'a, C, NC, A> AccountContainerTagCreateCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerTagCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerTagCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6506,7 +6502,7 @@ impl<'a, C, NC, A> AccountContainerTagCreateCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerTagCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerTagCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6544,10 +6540,10 @@ impl<'a, C, NC, A> AccountContainerTagCreateCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct AccountContainerTriggerListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerTriggerListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _container_id: String, _delegate: Option<&'a mut Delegate>, @@ -6555,9 +6551,9 @@ pub struct AccountContainerTriggerListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerTriggerListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerTriggerListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerTriggerListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerTriggerListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6690,7 +6686,7 @@ impl<'a, C, NC, A> AccountContainerTriggerListCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerTriggerListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerTriggerListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -6700,7 +6696,7 @@ impl<'a, C, NC, A> AccountContainerTriggerListCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerTriggerListCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerTriggerListCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -6711,7 +6707,7 @@ impl<'a, C, NC, A> AccountContainerTriggerListCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerTriggerListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerTriggerListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6732,7 +6728,7 @@ impl<'a, C, NC, A> AccountContainerTriggerListCall<'a, C, NC, A> where NC: hyper /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerTriggerListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerTriggerListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6749,7 +6745,7 @@ impl<'a, C, NC, A> AccountContainerTriggerListCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerTriggerListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerTriggerListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6787,10 +6783,10 @@ impl<'a, C, NC, A> AccountContainerTriggerListCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct AccountContainerVersionDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerVersionDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _container_id: String, _container_version_id: String, @@ -6799,9 +6795,9 @@ pub struct AccountContainerVersionDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerVersionDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerVersionDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerVersionDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerVersionDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6924,7 +6920,7 @@ impl<'a, C, NC, A> AccountContainerVersionDeleteCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerVersionDeleteCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerVersionDeleteCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -6934,7 +6930,7 @@ impl<'a, C, NC, A> AccountContainerVersionDeleteCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerVersionDeleteCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerVersionDeleteCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -6944,7 +6940,7 @@ impl<'a, C, NC, A> AccountContainerVersionDeleteCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// The GTM Container Version ID. - pub fn container_version_id(mut self, new_value: &str) -> AccountContainerVersionDeleteCall<'a, C, NC, A> { + pub fn container_version_id(mut self, new_value: &str) -> AccountContainerVersionDeleteCall<'a, C, A> { self._container_version_id = new_value.to_string(); self } @@ -6955,7 +6951,7 @@ impl<'a, C, NC, A> AccountContainerVersionDeleteCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVersionDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVersionDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6976,7 +6972,7 @@ impl<'a, C, NC, A> AccountContainerVersionDeleteCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerVersionDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerVersionDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6993,7 +6989,7 @@ impl<'a, C, NC, A> AccountContainerVersionDeleteCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerVersionDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerVersionDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7038,10 +7034,10 @@ impl<'a, C, NC, A> AccountContainerVersionDeleteCall<'a, C, NC, A> where NC: hyp /// .doit(); /// # } /// ``` -pub struct AccountUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _request: Account, _account_id: String, _fingerprint: Option, @@ -7050,9 +7046,9 @@ pub struct AccountUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7194,7 +7190,7 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Account) -> AccountUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Account) -> AccountUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7204,7 +7200,7 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -7212,7 +7208,7 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// When provided, this fingerprint must match the fingerprint of the account in storage. - pub fn fingerprint(mut self, new_value: &str) -> AccountUpdateCall<'a, C, NC, A> { + pub fn fingerprint(mut self, new_value: &str) -> AccountUpdateCall<'a, C, A> { self._fingerprint = Some(new_value.to_string()); self } @@ -7223,7 +7219,7 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7244,7 +7240,7 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7261,7 +7257,7 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7299,10 +7295,10 @@ impl<'a, C, NC, A> AccountUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct AccountContainerMacroDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerMacroDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _container_id: String, _macro_id: String, @@ -7311,9 +7307,9 @@ pub struct AccountContainerMacroDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerMacroDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerMacroDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerMacroDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerMacroDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7436,7 +7432,7 @@ impl<'a, C, NC, A> AccountContainerMacroDeleteCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerMacroDeleteCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerMacroDeleteCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -7446,7 +7442,7 @@ impl<'a, C, NC, A> AccountContainerMacroDeleteCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerMacroDeleteCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerMacroDeleteCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -7456,7 +7452,7 @@ impl<'a, C, NC, A> AccountContainerMacroDeleteCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The GTM Macro ID. - pub fn macro_id(mut self, new_value: &str) -> AccountContainerMacroDeleteCall<'a, C, NC, A> { + pub fn macro_id(mut self, new_value: &str) -> AccountContainerMacroDeleteCall<'a, C, A> { self._macro_id = new_value.to_string(); self } @@ -7467,7 +7463,7 @@ impl<'a, C, NC, A> AccountContainerMacroDeleteCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerMacroDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerMacroDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7488,7 +7484,7 @@ impl<'a, C, NC, A> AccountContainerMacroDeleteCall<'a, C, NC, A> where NC: hyper /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerMacroDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerMacroDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7505,7 +7501,7 @@ impl<'a, C, NC, A> AccountContainerMacroDeleteCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerMacroDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerMacroDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7549,10 +7545,10 @@ impl<'a, C, NC, A> AccountContainerMacroDeleteCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct AccountContainerVersionCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerVersionCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _request: CreateContainerVersionRequestVersionOptions, _account_id: String, _container_id: String, @@ -7561,9 +7557,9 @@ pub struct AccountContainerVersionCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerVersionCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerVersionCreateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerVersionCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerVersionCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7703,7 +7699,7 @@ impl<'a, C, NC, A> AccountContainerVersionCreateCall<'a, C, NC, A> where NC: hyp /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &CreateContainerVersionRequestVersionOptions) -> AccountContainerVersionCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &CreateContainerVersionRequestVersionOptions) -> AccountContainerVersionCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7713,7 +7709,7 @@ impl<'a, C, NC, A> AccountContainerVersionCreateCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerVersionCreateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerVersionCreateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -7723,7 +7719,7 @@ impl<'a, C, NC, A> AccountContainerVersionCreateCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerVersionCreateCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerVersionCreateCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -7734,7 +7730,7 @@ impl<'a, C, NC, A> AccountContainerVersionCreateCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVersionCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVersionCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7755,7 +7751,7 @@ impl<'a, C, NC, A> AccountContainerVersionCreateCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerVersionCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerVersionCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7772,7 +7768,7 @@ impl<'a, C, NC, A> AccountContainerVersionCreateCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerVersionCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerVersionCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7810,10 +7806,10 @@ impl<'a, C, NC, A> AccountContainerVersionCreateCall<'a, C, NC, A> where NC: hyp /// .doit(); /// # } /// ``` -pub struct AccountPermissionGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountPermissionGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _permission_id: String, _delegate: Option<&'a mut Delegate>, @@ -7821,9 +7817,9 @@ pub struct AccountPermissionGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountPermissionGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountPermissionGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountPermissionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountPermissionGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7956,7 +7952,7 @@ impl<'a, C, NC, A> AccountPermissionGetCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountPermissionGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountPermissionGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -7966,7 +7962,7 @@ impl<'a, C, NC, A> AccountPermissionGetCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The GTM User ID. - pub fn permission_id(mut self, new_value: &str) -> AccountPermissionGetCall<'a, C, NC, A> { + pub fn permission_id(mut self, new_value: &str) -> AccountPermissionGetCall<'a, C, A> { self._permission_id = new_value.to_string(); self } @@ -7977,7 +7973,7 @@ impl<'a, C, NC, A> AccountPermissionGetCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPermissionGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPermissionGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7998,7 +7994,7 @@ impl<'a, C, NC, A> AccountPermissionGetCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountPermissionGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountPermissionGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8015,7 +8011,7 @@ impl<'a, C, NC, A> AccountPermissionGetCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountPermissionGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountPermissionGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8059,10 +8055,10 @@ impl<'a, C, NC, A> AccountPermissionGetCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct AccountContainerRuleCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerRuleCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _request: Rule, _account_id: String, _container_id: String, @@ -8071,9 +8067,9 @@ pub struct AccountContainerRuleCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerRuleCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerRuleCreateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerRuleCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerRuleCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8213,7 +8209,7 @@ impl<'a, C, NC, A> AccountContainerRuleCreateCall<'a, C, NC, A> where NC: hyper: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Rule) -> AccountContainerRuleCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Rule) -> AccountContainerRuleCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8223,7 +8219,7 @@ impl<'a, C, NC, A> AccountContainerRuleCreateCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerRuleCreateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerRuleCreateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -8233,7 +8229,7 @@ impl<'a, C, NC, A> AccountContainerRuleCreateCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerRuleCreateCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerRuleCreateCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -8244,7 +8240,7 @@ impl<'a, C, NC, A> AccountContainerRuleCreateCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerRuleCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerRuleCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8265,7 +8261,7 @@ impl<'a, C, NC, A> AccountContainerRuleCreateCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerRuleCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerRuleCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8282,7 +8278,7 @@ impl<'a, C, NC, A> AccountContainerRuleCreateCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerRuleCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerRuleCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8320,10 +8316,10 @@ impl<'a, C, NC, A> AccountContainerRuleCreateCall<'a, C, NC, A> where NC: hyper: /// .doit(); /// # } /// ``` -pub struct AccountContainerVersionRestoreCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerVersionRestoreCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _container_id: String, _container_version_id: String, @@ -8332,9 +8328,9 @@ pub struct AccountContainerVersionRestoreCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerVersionRestoreCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerVersionRestoreCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerVersionRestoreCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerVersionRestoreCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8468,7 +8464,7 @@ impl<'a, C, NC, A> AccountContainerVersionRestoreCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerVersionRestoreCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerVersionRestoreCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -8478,7 +8474,7 @@ impl<'a, C, NC, A> AccountContainerVersionRestoreCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerVersionRestoreCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerVersionRestoreCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -8488,7 +8484,7 @@ impl<'a, C, NC, A> AccountContainerVersionRestoreCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// The GTM Container Version ID. - pub fn container_version_id(mut self, new_value: &str) -> AccountContainerVersionRestoreCall<'a, C, NC, A> { + pub fn container_version_id(mut self, new_value: &str) -> AccountContainerVersionRestoreCall<'a, C, A> { self._container_version_id = new_value.to_string(); self } @@ -8499,7 +8495,7 @@ impl<'a, C, NC, A> AccountContainerVersionRestoreCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVersionRestoreCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVersionRestoreCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8520,7 +8516,7 @@ impl<'a, C, NC, A> AccountContainerVersionRestoreCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerVersionRestoreCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerVersionRestoreCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8537,7 +8533,7 @@ impl<'a, C, NC, A> AccountContainerVersionRestoreCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerVersionRestoreCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerVersionRestoreCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8575,10 +8571,10 @@ impl<'a, C, NC, A> AccountContainerVersionRestoreCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct AccountContainerRuleGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerRuleGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _container_id: String, _rule_id: String, @@ -8587,9 +8583,9 @@ pub struct AccountContainerRuleGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerRuleGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerRuleGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerRuleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerRuleGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8723,7 +8719,7 @@ impl<'a, C, NC, A> AccountContainerRuleGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerRuleGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerRuleGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -8733,7 +8729,7 @@ impl<'a, C, NC, A> AccountContainerRuleGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerRuleGetCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerRuleGetCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -8743,7 +8739,7 @@ impl<'a, C, NC, A> AccountContainerRuleGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The GTM Rule ID. - pub fn rule_id(mut self, new_value: &str) -> AccountContainerRuleGetCall<'a, C, NC, A> { + pub fn rule_id(mut self, new_value: &str) -> AccountContainerRuleGetCall<'a, C, A> { self._rule_id = new_value.to_string(); self } @@ -8754,7 +8750,7 @@ impl<'a, C, NC, A> AccountContainerRuleGetCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerRuleGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerRuleGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8775,7 +8771,7 @@ impl<'a, C, NC, A> AccountContainerRuleGetCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerRuleGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerRuleGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8792,7 +8788,7 @@ impl<'a, C, NC, A> AccountContainerRuleGetCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerRuleGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerRuleGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8836,10 +8832,10 @@ impl<'a, C, NC, A> AccountContainerRuleGetCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct AccountContainerVariableCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerVariableCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _request: Variable, _account_id: String, _container_id: String, @@ -8848,9 +8844,9 @@ pub struct AccountContainerVariableCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerVariableCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerVariableCreateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerVariableCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerVariableCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8990,7 +8986,7 @@ impl<'a, C, NC, A> AccountContainerVariableCreateCall<'a, C, NC, A> where NC: hy /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Variable) -> AccountContainerVariableCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Variable) -> AccountContainerVariableCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9000,7 +8996,7 @@ impl<'a, C, NC, A> AccountContainerVariableCreateCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerVariableCreateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerVariableCreateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -9010,7 +9006,7 @@ impl<'a, C, NC, A> AccountContainerVariableCreateCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerVariableCreateCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerVariableCreateCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -9021,7 +9017,7 @@ impl<'a, C, NC, A> AccountContainerVariableCreateCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVariableCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVariableCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9042,7 +9038,7 @@ impl<'a, C, NC, A> AccountContainerVariableCreateCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerVariableCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerVariableCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9059,7 +9055,7 @@ impl<'a, C, NC, A> AccountContainerVariableCreateCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerVariableCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerVariableCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9097,10 +9093,10 @@ impl<'a, C, NC, A> AccountContainerVariableCreateCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct AccountContainerVariableListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerVariableListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _container_id: String, _delegate: Option<&'a mut Delegate>, @@ -9108,9 +9104,9 @@ pub struct AccountContainerVariableListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerVariableListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerVariableListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerVariableListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerVariableListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9243,7 +9239,7 @@ impl<'a, C, NC, A> AccountContainerVariableListCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerVariableListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerVariableListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -9253,7 +9249,7 @@ impl<'a, C, NC, A> AccountContainerVariableListCall<'a, C, NC, A> where NC: hype /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerVariableListCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerVariableListCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -9264,7 +9260,7 @@ impl<'a, C, NC, A> AccountContainerVariableListCall<'a, C, NC, A> where NC: hype /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVariableListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVariableListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9285,7 +9281,7 @@ impl<'a, C, NC, A> AccountContainerVariableListCall<'a, C, NC, A> where NC: hype /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerVariableListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerVariableListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9302,7 +9298,7 @@ impl<'a, C, NC, A> AccountContainerVariableListCall<'a, C, NC, A> where NC: hype /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerVariableListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerVariableListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9346,10 +9342,10 @@ impl<'a, C, NC, A> AccountContainerVariableListCall<'a, C, NC, A> where NC: hype /// .doit(); /// # } /// ``` -pub struct AccountContainerMacroCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerMacroCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _request: Macro, _account_id: String, _container_id: String, @@ -9358,9 +9354,9 @@ pub struct AccountContainerMacroCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerMacroCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerMacroCreateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerMacroCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerMacroCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9500,7 +9496,7 @@ impl<'a, C, NC, A> AccountContainerMacroCreateCall<'a, C, NC, A> where NC: hyper /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Macro) -> AccountContainerMacroCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Macro) -> AccountContainerMacroCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -9510,7 +9506,7 @@ impl<'a, C, NC, A> AccountContainerMacroCreateCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerMacroCreateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerMacroCreateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -9520,7 +9516,7 @@ impl<'a, C, NC, A> AccountContainerMacroCreateCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerMacroCreateCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerMacroCreateCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -9531,7 +9527,7 @@ impl<'a, C, NC, A> AccountContainerMacroCreateCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerMacroCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerMacroCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9552,7 +9548,7 @@ impl<'a, C, NC, A> AccountContainerMacroCreateCall<'a, C, NC, A> where NC: hyper /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerMacroCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerMacroCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9569,7 +9565,7 @@ impl<'a, C, NC, A> AccountContainerMacroCreateCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerMacroCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerMacroCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9607,10 +9603,10 @@ impl<'a, C, NC, A> AccountContainerMacroCreateCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct AccountContainerTagGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerTagGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _container_id: String, _tag_id: String, @@ -9619,9 +9615,9 @@ pub struct AccountContainerTagGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerTagGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerTagGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerTagGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerTagGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9755,7 +9751,7 @@ impl<'a, C, NC, A> AccountContainerTagGetCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerTagGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerTagGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -9765,7 +9761,7 @@ impl<'a, C, NC, A> AccountContainerTagGetCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerTagGetCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerTagGetCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -9775,7 +9771,7 @@ impl<'a, C, NC, A> AccountContainerTagGetCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The GTM Tag ID. - pub fn tag_id(mut self, new_value: &str) -> AccountContainerTagGetCall<'a, C, NC, A> { + pub fn tag_id(mut self, new_value: &str) -> AccountContainerTagGetCall<'a, C, A> { self._tag_id = new_value.to_string(); self } @@ -9786,7 +9782,7 @@ impl<'a, C, NC, A> AccountContainerTagGetCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerTagGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerTagGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9807,7 +9803,7 @@ impl<'a, C, NC, A> AccountContainerTagGetCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerTagGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerTagGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9824,7 +9820,7 @@ impl<'a, C, NC, A> AccountContainerTagGetCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerTagGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerTagGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9862,10 +9858,10 @@ impl<'a, C, NC, A> AccountContainerTagGetCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct AccountContainerVariableGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerVariableGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _container_id: String, _variable_id: String, @@ -9874,9 +9870,9 @@ pub struct AccountContainerVariableGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerVariableGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerVariableGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerVariableGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerVariableGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10010,7 +10006,7 @@ impl<'a, C, NC, A> AccountContainerVariableGetCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerVariableGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerVariableGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -10020,7 +10016,7 @@ impl<'a, C, NC, A> AccountContainerVariableGetCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerVariableGetCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerVariableGetCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -10030,7 +10026,7 @@ impl<'a, C, NC, A> AccountContainerVariableGetCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The GTM Variable ID. - pub fn variable_id(mut self, new_value: &str) -> AccountContainerVariableGetCall<'a, C, NC, A> { + pub fn variable_id(mut self, new_value: &str) -> AccountContainerVariableGetCall<'a, C, A> { self._variable_id = new_value.to_string(); self } @@ -10041,7 +10037,7 @@ impl<'a, C, NC, A> AccountContainerVariableGetCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVariableGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVariableGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10062,7 +10058,7 @@ impl<'a, C, NC, A> AccountContainerVariableGetCall<'a, C, NC, A> where NC: hyper /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerVariableGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerVariableGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10079,7 +10075,7 @@ impl<'a, C, NC, A> AccountContainerVariableGetCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerVariableGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerVariableGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10117,10 +10113,10 @@ impl<'a, C, NC, A> AccountContainerVariableGetCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct AccountContainerTriggerDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerTriggerDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _container_id: String, _trigger_id: String, @@ -10129,9 +10125,9 @@ pub struct AccountContainerTriggerDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerTriggerDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerTriggerDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerTriggerDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerTriggerDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10254,7 +10250,7 @@ impl<'a, C, NC, A> AccountContainerTriggerDeleteCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerTriggerDeleteCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerTriggerDeleteCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -10264,7 +10260,7 @@ impl<'a, C, NC, A> AccountContainerTriggerDeleteCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerTriggerDeleteCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerTriggerDeleteCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -10274,7 +10270,7 @@ impl<'a, C, NC, A> AccountContainerTriggerDeleteCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// The GTM Trigger ID. - pub fn trigger_id(mut self, new_value: &str) -> AccountContainerTriggerDeleteCall<'a, C, NC, A> { + pub fn trigger_id(mut self, new_value: &str) -> AccountContainerTriggerDeleteCall<'a, C, A> { self._trigger_id = new_value.to_string(); self } @@ -10285,7 +10281,7 @@ impl<'a, C, NC, A> AccountContainerTriggerDeleteCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerTriggerDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerTriggerDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10306,7 +10302,7 @@ impl<'a, C, NC, A> AccountContainerTriggerDeleteCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerTriggerDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerTriggerDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10323,7 +10319,7 @@ impl<'a, C, NC, A> AccountContainerTriggerDeleteCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerTriggerDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerTriggerDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10361,10 +10357,10 @@ impl<'a, C, NC, A> AccountContainerTriggerDeleteCall<'a, C, NC, A> where NC: hyp /// .doit(); /// # } /// ``` -pub struct AccountContainerMacroListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerMacroListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _container_id: String, _delegate: Option<&'a mut Delegate>, @@ -10372,9 +10368,9 @@ pub struct AccountContainerMacroListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerMacroListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerMacroListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerMacroListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerMacroListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10507,7 +10503,7 @@ impl<'a, C, NC, A> AccountContainerMacroListCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerMacroListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerMacroListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -10517,7 +10513,7 @@ impl<'a, C, NC, A> AccountContainerMacroListCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerMacroListCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerMacroListCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -10528,7 +10524,7 @@ impl<'a, C, NC, A> AccountContainerMacroListCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerMacroListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerMacroListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10549,7 +10545,7 @@ impl<'a, C, NC, A> AccountContainerMacroListCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerMacroListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerMacroListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10566,7 +10562,7 @@ impl<'a, C, NC, A> AccountContainerMacroListCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerMacroListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerMacroListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10610,10 +10606,10 @@ impl<'a, C, NC, A> AccountContainerMacroListCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct AccountContainerTriggerCreateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerTriggerCreateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _request: Trigger, _account_id: String, _container_id: String, @@ -10622,9 +10618,9 @@ pub struct AccountContainerTriggerCreateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerTriggerCreateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerTriggerCreateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerTriggerCreateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerTriggerCreateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10764,7 +10760,7 @@ impl<'a, C, NC, A> AccountContainerTriggerCreateCall<'a, C, NC, A> where NC: hyp /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Trigger) -> AccountContainerTriggerCreateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Trigger) -> AccountContainerTriggerCreateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -10774,7 +10770,7 @@ impl<'a, C, NC, A> AccountContainerTriggerCreateCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerTriggerCreateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerTriggerCreateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -10784,7 +10780,7 @@ impl<'a, C, NC, A> AccountContainerTriggerCreateCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerTriggerCreateCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerTriggerCreateCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -10795,7 +10791,7 @@ impl<'a, C, NC, A> AccountContainerTriggerCreateCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerTriggerCreateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerTriggerCreateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10816,7 +10812,7 @@ impl<'a, C, NC, A> AccountContainerTriggerCreateCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerTriggerCreateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerTriggerCreateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10833,7 +10829,7 @@ impl<'a, C, NC, A> AccountContainerTriggerCreateCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerTriggerCreateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerTriggerCreateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10878,10 +10874,10 @@ impl<'a, C, NC, A> AccountContainerTriggerCreateCall<'a, C, NC, A> where NC: hyp /// .doit(); /// # } /// ``` -pub struct AccountContainerMacroUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerMacroUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _request: Macro, _account_id: String, _container_id: String, @@ -10892,9 +10888,9 @@ pub struct AccountContainerMacroUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerMacroUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerMacroUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerMacroUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerMacroUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11038,7 +11034,7 @@ impl<'a, C, NC, A> AccountContainerMacroUpdateCall<'a, C, NC, A> where NC: hyper /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Macro) -> AccountContainerMacroUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Macro) -> AccountContainerMacroUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -11048,7 +11044,7 @@ impl<'a, C, NC, A> AccountContainerMacroUpdateCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerMacroUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerMacroUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -11058,7 +11054,7 @@ impl<'a, C, NC, A> AccountContainerMacroUpdateCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerMacroUpdateCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerMacroUpdateCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -11068,7 +11064,7 @@ impl<'a, C, NC, A> AccountContainerMacroUpdateCall<'a, C, NC, A> where NC: hyper /// we provide this method for API completeness. /// /// The GTM Macro ID. - pub fn macro_id(mut self, new_value: &str) -> AccountContainerMacroUpdateCall<'a, C, NC, A> { + pub fn macro_id(mut self, new_value: &str) -> AccountContainerMacroUpdateCall<'a, C, A> { self._macro_id = new_value.to_string(); self } @@ -11076,7 +11072,7 @@ impl<'a, C, NC, A> AccountContainerMacroUpdateCall<'a, C, NC, A> where NC: hyper /// /// /// When provided, this fingerprint must match the fingerprint of the macro in storage. - pub fn fingerprint(mut self, new_value: &str) -> AccountContainerMacroUpdateCall<'a, C, NC, A> { + pub fn fingerprint(mut self, new_value: &str) -> AccountContainerMacroUpdateCall<'a, C, A> { self._fingerprint = Some(new_value.to_string()); self } @@ -11087,7 +11083,7 @@ impl<'a, C, NC, A> AccountContainerMacroUpdateCall<'a, C, NC, A> where NC: hyper /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerMacroUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerMacroUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11108,7 +11104,7 @@ impl<'a, C, NC, A> AccountContainerMacroUpdateCall<'a, C, NC, A> where NC: hyper /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerMacroUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerMacroUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11125,7 +11121,7 @@ impl<'a, C, NC, A> AccountContainerMacroUpdateCall<'a, C, NC, A> where NC: hyper /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerMacroUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerMacroUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11163,18 +11159,18 @@ impl<'a, C, NC, A> AccountContainerMacroUpdateCall<'a, C, NC, A> where NC: hyper /// .doit(); /// # } /// ``` -pub struct AccountListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11282,7 +11278,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11303,7 +11299,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11320,7 +11316,7 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11364,10 +11360,10 @@ impl<'a, C, NC, A> AccountListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct AccountPermissionUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountPermissionUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _request: UserAccess, _account_id: String, _permission_id: String, @@ -11376,9 +11372,9 @@ pub struct AccountPermissionUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountPermissionUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountPermissionUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountPermissionUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountPermissionUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11518,7 +11514,7 @@ impl<'a, C, NC, A> AccountPermissionUpdateCall<'a, C, NC, A> where NC: hyper::ne /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &UserAccess) -> AccountPermissionUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &UserAccess) -> AccountPermissionUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -11528,7 +11524,7 @@ impl<'a, C, NC, A> AccountPermissionUpdateCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountPermissionUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountPermissionUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -11538,7 +11534,7 @@ impl<'a, C, NC, A> AccountPermissionUpdateCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The GTM User ID. - pub fn permission_id(mut self, new_value: &str) -> AccountPermissionUpdateCall<'a, C, NC, A> { + pub fn permission_id(mut self, new_value: &str) -> AccountPermissionUpdateCall<'a, C, A> { self._permission_id = new_value.to_string(); self } @@ -11549,7 +11545,7 @@ impl<'a, C, NC, A> AccountPermissionUpdateCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPermissionUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountPermissionUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11570,7 +11566,7 @@ impl<'a, C, NC, A> AccountPermissionUpdateCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountPermissionUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountPermissionUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11587,7 +11583,7 @@ impl<'a, C, NC, A> AccountPermissionUpdateCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountPermissionUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountPermissionUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11625,10 +11621,10 @@ impl<'a, C, NC, A> AccountPermissionUpdateCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct AccountContainerVariableDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerVariableDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _container_id: String, _variable_id: String, @@ -11637,9 +11633,9 @@ pub struct AccountContainerVariableDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerVariableDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerVariableDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerVariableDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerVariableDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11762,7 +11758,7 @@ impl<'a, C, NC, A> AccountContainerVariableDeleteCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerVariableDeleteCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerVariableDeleteCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -11772,7 +11768,7 @@ impl<'a, C, NC, A> AccountContainerVariableDeleteCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerVariableDeleteCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerVariableDeleteCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -11782,7 +11778,7 @@ impl<'a, C, NC, A> AccountContainerVariableDeleteCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// The GTM Variable ID. - pub fn variable_id(mut self, new_value: &str) -> AccountContainerVariableDeleteCall<'a, C, NC, A> { + pub fn variable_id(mut self, new_value: &str) -> AccountContainerVariableDeleteCall<'a, C, A> { self._variable_id = new_value.to_string(); self } @@ -11793,7 +11789,7 @@ impl<'a, C, NC, A> AccountContainerVariableDeleteCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVariableDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVariableDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11814,7 +11810,7 @@ impl<'a, C, NC, A> AccountContainerVariableDeleteCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerVariableDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerVariableDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11831,7 +11827,7 @@ impl<'a, C, NC, A> AccountContainerVariableDeleteCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerVariableDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerVariableDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11869,19 +11865,19 @@ impl<'a, C, NC, A> AccountContainerVariableDeleteCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct AccountGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12013,7 +12009,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -12024,7 +12020,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12045,7 +12041,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12062,7 +12058,7 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12107,10 +12103,10 @@ impl<'a, C, NC, A> AccountGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct AccountContainerUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _request: Container, _account_id: String, _container_id: String, @@ -12120,9 +12116,9 @@ pub struct AccountContainerUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12265,7 +12261,7 @@ impl<'a, C, NC, A> AccountContainerUpdateCall<'a, C, NC, A> where NC: hyper::net /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Container) -> AccountContainerUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Container) -> AccountContainerUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -12275,7 +12271,7 @@ impl<'a, C, NC, A> AccountContainerUpdateCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -12285,7 +12281,7 @@ impl<'a, C, NC, A> AccountContainerUpdateCall<'a, C, NC, A> where NC: hyper::net /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerUpdateCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerUpdateCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -12293,7 +12289,7 @@ impl<'a, C, NC, A> AccountContainerUpdateCall<'a, C, NC, A> where NC: hyper::net /// /// /// When provided, this fingerprint must match the fingerprint of the container in storage. - pub fn fingerprint(mut self, new_value: &str) -> AccountContainerUpdateCall<'a, C, NC, A> { + pub fn fingerprint(mut self, new_value: &str) -> AccountContainerUpdateCall<'a, C, A> { self._fingerprint = Some(new_value.to_string()); self } @@ -12304,7 +12300,7 @@ impl<'a, C, NC, A> AccountContainerUpdateCall<'a, C, NC, A> where NC: hyper::net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12325,7 +12321,7 @@ impl<'a, C, NC, A> AccountContainerUpdateCall<'a, C, NC, A> where NC: hyper::net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12342,7 +12338,7 @@ impl<'a, C, NC, A> AccountContainerUpdateCall<'a, C, NC, A> where NC: hyper::net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12380,10 +12376,10 @@ impl<'a, C, NC, A> AccountContainerUpdateCall<'a, C, NC, A> where NC: hyper::net /// .doit(); /// # } /// ``` -pub struct AccountContainerRuleListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerRuleListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _container_id: String, _delegate: Option<&'a mut Delegate>, @@ -12391,9 +12387,9 @@ pub struct AccountContainerRuleListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerRuleListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerRuleListCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerRuleListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerRuleListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12526,7 +12522,7 @@ impl<'a, C, NC, A> AccountContainerRuleListCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerRuleListCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerRuleListCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -12536,7 +12532,7 @@ impl<'a, C, NC, A> AccountContainerRuleListCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerRuleListCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerRuleListCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -12547,7 +12543,7 @@ impl<'a, C, NC, A> AccountContainerRuleListCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerRuleListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerRuleListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12568,7 +12564,7 @@ impl<'a, C, NC, A> AccountContainerRuleListCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerRuleListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerRuleListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12585,7 +12581,7 @@ impl<'a, C, NC, A> AccountContainerRuleListCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerRuleListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerRuleListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12630,10 +12626,10 @@ impl<'a, C, NC, A> AccountContainerRuleListCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct AccountContainerTagUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerTagUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _request: Tag, _account_id: String, _container_id: String, @@ -12644,9 +12640,9 @@ pub struct AccountContainerTagUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerTagUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerTagUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerTagUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerTagUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12790,7 +12786,7 @@ impl<'a, C, NC, A> AccountContainerTagUpdateCall<'a, C, NC, A> where NC: hyper:: /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Tag) -> AccountContainerTagUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Tag) -> AccountContainerTagUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -12800,7 +12796,7 @@ impl<'a, C, NC, A> AccountContainerTagUpdateCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerTagUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerTagUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -12810,7 +12806,7 @@ impl<'a, C, NC, A> AccountContainerTagUpdateCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerTagUpdateCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerTagUpdateCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -12820,7 +12816,7 @@ impl<'a, C, NC, A> AccountContainerTagUpdateCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The GTM Tag ID. - pub fn tag_id(mut self, new_value: &str) -> AccountContainerTagUpdateCall<'a, C, NC, A> { + pub fn tag_id(mut self, new_value: &str) -> AccountContainerTagUpdateCall<'a, C, A> { self._tag_id = new_value.to_string(); self } @@ -12828,7 +12824,7 @@ impl<'a, C, NC, A> AccountContainerTagUpdateCall<'a, C, NC, A> where NC: hyper:: /// /// /// When provided, this fingerprint must match the fingerprint of the tag in storage. - pub fn fingerprint(mut self, new_value: &str) -> AccountContainerTagUpdateCall<'a, C, NC, A> { + pub fn fingerprint(mut self, new_value: &str) -> AccountContainerTagUpdateCall<'a, C, A> { self._fingerprint = Some(new_value.to_string()); self } @@ -12839,7 +12835,7 @@ impl<'a, C, NC, A> AccountContainerTagUpdateCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerTagUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerTagUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12860,7 +12856,7 @@ impl<'a, C, NC, A> AccountContainerTagUpdateCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerTagUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerTagUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12877,7 +12873,7 @@ impl<'a, C, NC, A> AccountContainerTagUpdateCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerTagUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerTagUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12915,10 +12911,10 @@ impl<'a, C, NC, A> AccountContainerTagUpdateCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct AccountContainerMacroGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerMacroGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _container_id: String, _macro_id: String, @@ -12927,9 +12923,9 @@ pub struct AccountContainerMacroGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerMacroGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerMacroGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerMacroGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerMacroGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13063,7 +13059,7 @@ impl<'a, C, NC, A> AccountContainerMacroGetCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerMacroGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerMacroGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -13073,7 +13069,7 @@ impl<'a, C, NC, A> AccountContainerMacroGetCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerMacroGetCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerMacroGetCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -13083,7 +13079,7 @@ impl<'a, C, NC, A> AccountContainerMacroGetCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The GTM Macro ID. - pub fn macro_id(mut self, new_value: &str) -> AccountContainerMacroGetCall<'a, C, NC, A> { + pub fn macro_id(mut self, new_value: &str) -> AccountContainerMacroGetCall<'a, C, A> { self._macro_id = new_value.to_string(); self } @@ -13094,7 +13090,7 @@ impl<'a, C, NC, A> AccountContainerMacroGetCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerMacroGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerMacroGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13115,7 +13111,7 @@ impl<'a, C, NC, A> AccountContainerMacroGetCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerMacroGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerMacroGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13132,7 +13128,7 @@ impl<'a, C, NC, A> AccountContainerMacroGetCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerMacroGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerMacroGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13177,10 +13173,10 @@ impl<'a, C, NC, A> AccountContainerMacroGetCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct AccountContainerVersionUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerVersionUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _request: ContainerVersion, _account_id: String, _container_id: String, @@ -13191,9 +13187,9 @@ pub struct AccountContainerVersionUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerVersionUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerVersionUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerVersionUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerVersionUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13337,7 +13333,7 @@ impl<'a, C, NC, A> AccountContainerVersionUpdateCall<'a, C, NC, A> where NC: hyp /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ContainerVersion) -> AccountContainerVersionUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ContainerVersion) -> AccountContainerVersionUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13347,7 +13343,7 @@ impl<'a, C, NC, A> AccountContainerVersionUpdateCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerVersionUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerVersionUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -13357,7 +13353,7 @@ impl<'a, C, NC, A> AccountContainerVersionUpdateCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerVersionUpdateCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerVersionUpdateCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -13367,7 +13363,7 @@ impl<'a, C, NC, A> AccountContainerVersionUpdateCall<'a, C, NC, A> where NC: hyp /// we provide this method for API completeness. /// /// The GTM Container Version ID. - pub fn container_version_id(mut self, new_value: &str) -> AccountContainerVersionUpdateCall<'a, C, NC, A> { + pub fn container_version_id(mut self, new_value: &str) -> AccountContainerVersionUpdateCall<'a, C, A> { self._container_version_id = new_value.to_string(); self } @@ -13375,7 +13371,7 @@ impl<'a, C, NC, A> AccountContainerVersionUpdateCall<'a, C, NC, A> where NC: hyp /// /// /// When provided, this fingerprint must match the fingerprint of the container version in storage. - pub fn fingerprint(mut self, new_value: &str) -> AccountContainerVersionUpdateCall<'a, C, NC, A> { + pub fn fingerprint(mut self, new_value: &str) -> AccountContainerVersionUpdateCall<'a, C, A> { self._fingerprint = Some(new_value.to_string()); self } @@ -13386,7 +13382,7 @@ impl<'a, C, NC, A> AccountContainerVersionUpdateCall<'a, C, NC, A> where NC: hyp /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVersionUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVersionUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13407,7 +13403,7 @@ impl<'a, C, NC, A> AccountContainerVersionUpdateCall<'a, C, NC, A> where NC: hyp /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerVersionUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerVersionUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13424,7 +13420,7 @@ impl<'a, C, NC, A> AccountContainerVersionUpdateCall<'a, C, NC, A> where NC: hyp /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerVersionUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerVersionUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13469,10 +13465,10 @@ impl<'a, C, NC, A> AccountContainerVersionUpdateCall<'a, C, NC, A> where NC: hyp /// .doit(); /// # } /// ``` -pub struct AccountContainerVariableUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerVariableUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _request: Variable, _account_id: String, _container_id: String, @@ -13483,9 +13479,9 @@ pub struct AccountContainerVariableUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerVariableUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerVariableUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerVariableUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerVariableUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13629,7 +13625,7 @@ impl<'a, C, NC, A> AccountContainerVariableUpdateCall<'a, C, NC, A> where NC: hy /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Variable) -> AccountContainerVariableUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Variable) -> AccountContainerVariableUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13639,7 +13635,7 @@ impl<'a, C, NC, A> AccountContainerVariableUpdateCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerVariableUpdateCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerVariableUpdateCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -13649,7 +13645,7 @@ impl<'a, C, NC, A> AccountContainerVariableUpdateCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerVariableUpdateCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerVariableUpdateCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -13659,7 +13655,7 @@ impl<'a, C, NC, A> AccountContainerVariableUpdateCall<'a, C, NC, A> where NC: hy /// we provide this method for API completeness. /// /// The GTM Variable ID. - pub fn variable_id(mut self, new_value: &str) -> AccountContainerVariableUpdateCall<'a, C, NC, A> { + pub fn variable_id(mut self, new_value: &str) -> AccountContainerVariableUpdateCall<'a, C, A> { self._variable_id = new_value.to_string(); self } @@ -13667,7 +13663,7 @@ impl<'a, C, NC, A> AccountContainerVariableUpdateCall<'a, C, NC, A> where NC: hy /// /// /// When provided, this fingerprint must match the fingerprint of the variable in storage. - pub fn fingerprint(mut self, new_value: &str) -> AccountContainerVariableUpdateCall<'a, C, NC, A> { + pub fn fingerprint(mut self, new_value: &str) -> AccountContainerVariableUpdateCall<'a, C, A> { self._fingerprint = Some(new_value.to_string()); self } @@ -13678,7 +13674,7 @@ impl<'a, C, NC, A> AccountContainerVariableUpdateCall<'a, C, NC, A> where NC: hy /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVariableUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVariableUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13699,7 +13695,7 @@ impl<'a, C, NC, A> AccountContainerVariableUpdateCall<'a, C, NC, A> where NC: hy /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerVariableUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerVariableUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13716,7 +13712,7 @@ impl<'a, C, NC, A> AccountContainerVariableUpdateCall<'a, C, NC, A> where NC: hy /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerVariableUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerVariableUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13754,10 +13750,10 @@ impl<'a, C, NC, A> AccountContainerVariableUpdateCall<'a, C, NC, A> where NC: hy /// .doit(); /// # } /// ``` -pub struct AccountContainerVersionGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct AccountContainerVersionGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TagManager, + hub: &'a TagManager, _account_id: String, _container_id: String, _container_version_id: String, @@ -13766,9 +13762,9 @@ pub struct AccountContainerVersionGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for AccountContainerVersionGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for AccountContainerVersionGetCall<'a, C, A> {} -impl<'a, C, NC, A> AccountContainerVersionGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> AccountContainerVersionGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13902,7 +13898,7 @@ impl<'a, C, NC, A> AccountContainerVersionGetCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The GTM Account ID. - pub fn account_id(mut self, new_value: &str) -> AccountContainerVersionGetCall<'a, C, NC, A> { + pub fn account_id(mut self, new_value: &str) -> AccountContainerVersionGetCall<'a, C, A> { self._account_id = new_value.to_string(); self } @@ -13912,7 +13908,7 @@ impl<'a, C, NC, A> AccountContainerVersionGetCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The GTM Container ID. - pub fn container_id(mut self, new_value: &str) -> AccountContainerVersionGetCall<'a, C, NC, A> { + pub fn container_id(mut self, new_value: &str) -> AccountContainerVersionGetCall<'a, C, A> { self._container_id = new_value.to_string(); self } @@ -13922,7 +13918,7 @@ impl<'a, C, NC, A> AccountContainerVersionGetCall<'a, C, NC, A> where NC: hyper: /// we provide this method for API completeness. /// /// The GTM Container Version ID. Specify published to retrieve the currently published version. - pub fn container_version_id(mut self, new_value: &str) -> AccountContainerVersionGetCall<'a, C, NC, A> { + pub fn container_version_id(mut self, new_value: &str) -> AccountContainerVersionGetCall<'a, C, A> { self._container_version_id = new_value.to_string(); self } @@ -13933,7 +13929,7 @@ impl<'a, C, NC, A> AccountContainerVersionGetCall<'a, C, NC, A> where NC: hyper: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVersionGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> AccountContainerVersionGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13954,7 +13950,7 @@ impl<'a, C, NC, A> AccountContainerVersionGetCall<'a, C, NC, A> where NC: hyper: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> AccountContainerVersionGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> AccountContainerVersionGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13971,7 +13967,7 @@ impl<'a, C, NC, A> AccountContainerVersionGetCall<'a, C, NC, A> where NC: hyper: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> AccountContainerVersionGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> AccountContainerVersionGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/taskqueue1_beta2/Cargo.toml b/gen/taskqueue1_beta2/Cargo.toml index 3887d663c6d..771116eb8cc 100644 --- a/gen/taskqueue1_beta2/Cargo.toml +++ b/gen/taskqueue1_beta2/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-taskqueue1_beta2" -version = "0.1.4+20141111" +version = "0.1.5+20141111" authors = ["Sebastian Thiel "] description = "A complete library to interact with taskqueue (protocol v1beta2)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/taskqueue1_beta2" homepage = "https://developers.google.com/appengine/docs/python/taskqueue/rest" -documentation = "http://byron.github.io/google-apis-rs/google-taskqueue1_beta2" +documentation = "http://byron.github.io/google-apis-rs/google_taskqueue1_beta2" license = "MIT" keywords = ["taskqueue", "google", "protocol", "web", "api"] diff --git a/gen/taskqueue1_beta2/README.md b/gen/taskqueue1_beta2/README.md index 205ce2193a7..e3e3af97692 100644 --- a/gen/taskqueue1_beta2/README.md +++ b/gen/taskqueue1_beta2/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-taskqueue1_beta2` library allows access to all features of the *Google taskqueue* service. -This documentation was generated from *taskqueue* crate version *0.1.4+20141111*, where *20141111* is the exact revision of the *taskqueue:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *taskqueue* crate version *0.1.5+20141111*, where *20141111* is the exact revision of the *taskqueue:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *taskqueue* *v1_beta2* API can be found at the [official documentation site](https://developers.google.com/appengine/docs/python/taskqueue/rest). diff --git a/gen/taskqueue1_beta2/src/cmn.rs b/gen/taskqueue1_beta2/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/taskqueue1_beta2/src/cmn.rs +++ b/gen/taskqueue1_beta2/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/taskqueue1_beta2/src/lib.rs b/gen/taskqueue1_beta2/src/lib.rs index 5302f6c3f40..2f9ff3f167e 100644 --- a/gen/taskqueue1_beta2/src/lib.rs +++ b/gen/taskqueue1_beta2/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *taskqueue* crate version *0.1.4+20141111*, where *20141111* is the exact revision of the *taskqueue:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *taskqueue* crate version *0.1.5+20141111*, where *20141111* is the exact revision of the *taskqueue:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *taskqueue* *v1_beta2* API can be found at the //! [official documentation site](https://developers.google.com/appengine/docs/python/taskqueue/rest). @@ -198,7 +198,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -295,37 +294,34 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Taskqueue { +pub struct Taskqueue { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Taskqueue {} +impl<'a, C, A> Hub for Taskqueue {} -impl<'a, C, NC, A> Taskqueue - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Taskqueue + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Taskqueue { + pub fn new(client: C, authenticator: A) -> Taskqueue { Taskqueue { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn taskqueues(&'a self) -> TaskqueueMethods<'a, C, NC, A> { + pub fn taskqueues(&'a self) -> TaskqueueMethods<'a, C, A> { TaskqueueMethods { hub: &self } } - pub fn tasks(&'a self) -> TaskMethods<'a, C, NC, A> { + pub fn tasks(&'a self) -> TaskMethods<'a, C, A> { TaskMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -529,15 +525,15 @@ impl ResponseResult for Tasks {} /// let rb = hub.taskqueues(); /// # } /// ``` -pub struct TaskqueueMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TaskqueueMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Taskqueue, + hub: &'a Taskqueue, } -impl<'a, C, NC, A> MethodsBuilder for TaskqueueMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TaskqueueMethods<'a, C, A> {} -impl<'a, C, NC, A> TaskqueueMethods<'a, C, NC, A> { +impl<'a, C, A> TaskqueueMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -547,7 +543,7 @@ impl<'a, C, NC, A> TaskqueueMethods<'a, C, NC, A> { /// /// * `project` - The project under which the queue lies. /// * `taskqueue` - The id of the taskqueue to get the properties of. - pub fn get(&self, project: &str, taskqueue: &str) -> TaskqueueGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, taskqueue: &str) -> TaskqueueGetCall<'a, C, A> { TaskqueueGetCall { hub: self.hub, _project: project.to_string(), @@ -590,15 +586,15 @@ impl<'a, C, NC, A> TaskqueueMethods<'a, C, NC, A> { /// let rb = hub.tasks(); /// # } /// ``` -pub struct TaskMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TaskMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Taskqueue, + hub: &'a Taskqueue, } -impl<'a, C, NC, A> MethodsBuilder for TaskMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TaskMethods<'a, C, A> {} -impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { +impl<'a, C, A> TaskMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -610,7 +606,7 @@ impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { /// * `taskqueue` - The taskqueue to lease a task from. /// * `numTasks` - The number of tasks to lease. /// * `leaseSecs` - The lease in seconds. - pub fn lease(&self, project: &str, taskqueue: &str, num_tasks: i32, lease_secs: i32) -> TaskLeaseCall<'a, C, NC, A> { + pub fn lease(&self, project: &str, taskqueue: &str, num_tasks: i32, lease_secs: i32) -> TaskLeaseCall<'a, C, A> { TaskLeaseCall { hub: self.hub, _project: project.to_string(), @@ -634,7 +630,7 @@ impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `project` - The project under which the queue lies /// * `taskqueue` - The taskqueue to insert the task into - pub fn insert(&self, request: &Task, project: &str, taskqueue: &str) -> TaskInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Task, project: &str, taskqueue: &str) -> TaskInsertCall<'a, C, A> { TaskInsertCall { hub: self.hub, _request: request.clone(), @@ -655,7 +651,7 @@ impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { /// * `project` - The project under which the queue lies. /// * `taskqueue` - The taskqueue to delete a task from. /// * `task` - The id of the task to delete. - pub fn delete(&self, project: &str, taskqueue: &str, task: &str) -> TaskDeleteCall<'a, C, NC, A> { + pub fn delete(&self, project: &str, taskqueue: &str, task: &str) -> TaskDeleteCall<'a, C, A> { TaskDeleteCall { hub: self.hub, _project: project.to_string(), @@ -678,7 +674,7 @@ impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { /// * `taskqueue` - No description provided. /// * `task` - No description provided. /// * `newLeaseSeconds` - The new lease in seconds. - pub fn patch(&self, request: &Task, project: &str, taskqueue: &str, task: &str, new_lease_seconds: i32) -> TaskPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Task, project: &str, taskqueue: &str, task: &str, new_lease_seconds: i32) -> TaskPatchCall<'a, C, A> { TaskPatchCall { hub: self.hub, _request: request.clone(), @@ -700,7 +696,7 @@ impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { /// /// * `project` - The project under which the queue lies. /// * `taskqueue` - The id of the taskqueue to list tasks from. - pub fn list(&self, project: &str, taskqueue: &str) -> TaskListCall<'a, C, NC, A> { + pub fn list(&self, project: &str, taskqueue: &str) -> TaskListCall<'a, C, A> { TaskListCall { hub: self.hub, _project: project.to_string(), @@ -720,7 +716,7 @@ impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { /// * `project` - The project under which the queue lies. /// * `taskqueue` - The taskqueue in which the task belongs. /// * `task` - The task to get properties of. - pub fn get(&self, project: &str, taskqueue: &str, task: &str) -> TaskGetCall<'a, C, NC, A> { + pub fn get(&self, project: &str, taskqueue: &str, task: &str) -> TaskGetCall<'a, C, A> { TaskGetCall { hub: self.hub, _project: project.to_string(), @@ -743,7 +739,7 @@ impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { /// * `taskqueue` - No description provided. /// * `task` - No description provided. /// * `newLeaseSeconds` - The new lease in seconds. - pub fn update(&self, request: &Task, project: &str, taskqueue: &str, task: &str, new_lease_seconds: i32) -> TaskUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Task, project: &str, taskqueue: &str, task: &str, new_lease_seconds: i32) -> TaskUpdateCall<'a, C, A> { TaskUpdateCall { hub: self.hub, _request: request.clone(), @@ -797,10 +793,10 @@ impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct TaskqueueGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TaskqueueGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Taskqueue, + hub: &'a Taskqueue, _project: String, _taskqueue: String, _get_stats: Option, @@ -809,9 +805,9 @@ pub struct TaskqueueGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TaskqueueGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TaskqueueGetCall<'a, C, A> {} -impl<'a, C, NC, A> TaskqueueGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TaskqueueGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -947,7 +943,7 @@ impl<'a, C, NC, A> TaskqueueGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The project under which the queue lies. - pub fn project(mut self, new_value: &str) -> TaskqueueGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TaskqueueGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -957,7 +953,7 @@ impl<'a, C, NC, A> TaskqueueGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The id of the taskqueue to get the properties of. - pub fn taskqueue(mut self, new_value: &str) -> TaskqueueGetCall<'a, C, NC, A> { + pub fn taskqueue(mut self, new_value: &str) -> TaskqueueGetCall<'a, C, A> { self._taskqueue = new_value.to_string(); self } @@ -965,7 +961,7 @@ impl<'a, C, NC, A> TaskqueueGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Whether to get stats. Optional. - pub fn get_stats(mut self, new_value: bool) -> TaskqueueGetCall<'a, C, NC, A> { + pub fn get_stats(mut self, new_value: bool) -> TaskqueueGetCall<'a, C, A> { self._get_stats = Some(new_value); self } @@ -976,7 +972,7 @@ impl<'a, C, NC, A> TaskqueueGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskqueueGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskqueueGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -997,7 +993,7 @@ impl<'a, C, NC, A> TaskqueueGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TaskqueueGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TaskqueueGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1014,7 +1010,7 @@ impl<'a, C, NC, A> TaskqueueGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TaskqueueGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TaskqueueGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1054,10 +1050,10 @@ impl<'a, C, NC, A> TaskqueueGetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct TaskLeaseCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TaskLeaseCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Taskqueue, + hub: &'a Taskqueue, _project: String, _taskqueue: String, _num_tasks: i32, @@ -1069,9 +1065,9 @@ pub struct TaskLeaseCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TaskLeaseCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TaskLeaseCall<'a, C, A> {} -impl<'a, C, NC, A> TaskLeaseCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TaskLeaseCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1212,7 +1208,7 @@ impl<'a, C, NC, A> TaskLeaseCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The project under which the queue lies. - pub fn project(mut self, new_value: &str) -> TaskLeaseCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TaskLeaseCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1222,7 +1218,7 @@ impl<'a, C, NC, A> TaskLeaseCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The taskqueue to lease a task from. - pub fn taskqueue(mut self, new_value: &str) -> TaskLeaseCall<'a, C, NC, A> { + pub fn taskqueue(mut self, new_value: &str) -> TaskLeaseCall<'a, C, A> { self._taskqueue = new_value.to_string(); self } @@ -1232,7 +1228,7 @@ impl<'a, C, NC, A> TaskLeaseCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The number of tasks to lease. - pub fn num_tasks(mut self, new_value: i32) -> TaskLeaseCall<'a, C, NC, A> { + pub fn num_tasks(mut self, new_value: i32) -> TaskLeaseCall<'a, C, A> { self._num_tasks = new_value; self } @@ -1242,7 +1238,7 @@ impl<'a, C, NC, A> TaskLeaseCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The lease in seconds. - pub fn lease_secs(mut self, new_value: i32) -> TaskLeaseCall<'a, C, NC, A> { + pub fn lease_secs(mut self, new_value: i32) -> TaskLeaseCall<'a, C, A> { self._lease_secs = new_value; self } @@ -1250,7 +1246,7 @@ impl<'a, C, NC, A> TaskLeaseCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The tag allowed for tasks in the response. Must only be specified if group_by_tag is true. If group_by_tag is true and tag is not specified the tag will be that of the oldest task by eta, i.e. the first available tag - pub fn tag(mut self, new_value: &str) -> TaskLeaseCall<'a, C, NC, A> { + pub fn tag(mut self, new_value: &str) -> TaskLeaseCall<'a, C, A> { self._tag = Some(new_value.to_string()); self } @@ -1258,7 +1254,7 @@ impl<'a, C, NC, A> TaskLeaseCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// When true, all returned tasks will have the same tag - pub fn group_by_tag(mut self, new_value: bool) -> TaskLeaseCall<'a, C, NC, A> { + pub fn group_by_tag(mut self, new_value: bool) -> TaskLeaseCall<'a, C, A> { self._group_by_tag = Some(new_value); self } @@ -1269,7 +1265,7 @@ impl<'a, C, NC, A> TaskLeaseCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskLeaseCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskLeaseCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1290,7 +1286,7 @@ impl<'a, C, NC, A> TaskLeaseCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TaskLeaseCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TaskLeaseCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1307,7 +1303,7 @@ impl<'a, C, NC, A> TaskLeaseCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TaskLeaseCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TaskLeaseCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1351,10 +1347,10 @@ impl<'a, C, NC, A> TaskLeaseCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct TaskInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TaskInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Taskqueue, + hub: &'a Taskqueue, _request: Task, _project: String, _taskqueue: String, @@ -1363,9 +1359,9 @@ pub struct TaskInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TaskInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TaskInsertCall<'a, C, A> {} -impl<'a, C, NC, A> TaskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TaskInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1505,7 +1501,7 @@ impl<'a, C, NC, A> TaskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Task) -> TaskInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Task) -> TaskInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1515,7 +1511,7 @@ impl<'a, C, NC, A> TaskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The project under which the queue lies - pub fn project(mut self, new_value: &str) -> TaskInsertCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TaskInsertCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1525,7 +1521,7 @@ impl<'a, C, NC, A> TaskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The taskqueue to insert the task into - pub fn taskqueue(mut self, new_value: &str) -> TaskInsertCall<'a, C, NC, A> { + pub fn taskqueue(mut self, new_value: &str) -> TaskInsertCall<'a, C, A> { self._taskqueue = new_value.to_string(); self } @@ -1536,7 +1532,7 @@ impl<'a, C, NC, A> TaskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1557,7 +1553,7 @@ impl<'a, C, NC, A> TaskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TaskInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TaskInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1574,7 +1570,7 @@ impl<'a, C, NC, A> TaskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TaskInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TaskInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1612,10 +1608,10 @@ impl<'a, C, NC, A> TaskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct TaskDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TaskDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Taskqueue, + hub: &'a Taskqueue, _project: String, _taskqueue: String, _task: String, @@ -1624,9 +1620,9 @@ pub struct TaskDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TaskDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TaskDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> TaskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TaskDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1749,7 +1745,7 @@ impl<'a, C, NC, A> TaskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The project under which the queue lies. - pub fn project(mut self, new_value: &str) -> TaskDeleteCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TaskDeleteCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -1759,7 +1755,7 @@ impl<'a, C, NC, A> TaskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The taskqueue to delete a task from. - pub fn taskqueue(mut self, new_value: &str) -> TaskDeleteCall<'a, C, NC, A> { + pub fn taskqueue(mut self, new_value: &str) -> TaskDeleteCall<'a, C, A> { self._taskqueue = new_value.to_string(); self } @@ -1769,7 +1765,7 @@ impl<'a, C, NC, A> TaskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The id of the task to delete. - pub fn task(mut self, new_value: &str) -> TaskDeleteCall<'a, C, NC, A> { + pub fn task(mut self, new_value: &str) -> TaskDeleteCall<'a, C, A> { self._task = new_value.to_string(); self } @@ -1780,7 +1776,7 @@ impl<'a, C, NC, A> TaskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1801,7 +1797,7 @@ impl<'a, C, NC, A> TaskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TaskDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TaskDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1818,7 +1814,7 @@ impl<'a, C, NC, A> TaskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TaskDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TaskDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1862,10 +1858,10 @@ impl<'a, C, NC, A> TaskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct TaskPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TaskPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Taskqueue, + hub: &'a Taskqueue, _request: Task, _project: String, _taskqueue: String, @@ -1876,9 +1872,9 @@ pub struct TaskPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TaskPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TaskPatchCall<'a, C, A> {} -impl<'a, C, NC, A> TaskPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TaskPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2020,7 +2016,7 @@ impl<'a, C, NC, A> TaskPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Task) -> TaskPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Task) -> TaskPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2030,7 +2026,7 @@ impl<'a, C, NC, A> TaskPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The project under which the queue lies. - pub fn project(mut self, new_value: &str) -> TaskPatchCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TaskPatchCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2039,7 +2035,7 @@ impl<'a, C, NC, A> TaskPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn taskqueue(mut self, new_value: &str) -> TaskPatchCall<'a, C, NC, A> { + pub fn taskqueue(mut self, new_value: &str) -> TaskPatchCall<'a, C, A> { self._taskqueue = new_value.to_string(); self } @@ -2048,7 +2044,7 @@ impl<'a, C, NC, A> TaskPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn task(mut self, new_value: &str) -> TaskPatchCall<'a, C, NC, A> { + pub fn task(mut self, new_value: &str) -> TaskPatchCall<'a, C, A> { self._task = new_value.to_string(); self } @@ -2058,7 +2054,7 @@ impl<'a, C, NC, A> TaskPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The new lease in seconds. - pub fn new_lease_seconds(mut self, new_value: i32) -> TaskPatchCall<'a, C, NC, A> { + pub fn new_lease_seconds(mut self, new_value: i32) -> TaskPatchCall<'a, C, A> { self._new_lease_seconds = new_value; self } @@ -2069,7 +2065,7 @@ impl<'a, C, NC, A> TaskPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2090,7 +2086,7 @@ impl<'a, C, NC, A> TaskPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TaskPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TaskPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2107,7 +2103,7 @@ impl<'a, C, NC, A> TaskPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TaskPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TaskPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2145,10 +2141,10 @@ impl<'a, C, NC, A> TaskPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct TaskListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TaskListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Taskqueue, + hub: &'a Taskqueue, _project: String, _taskqueue: String, _delegate: Option<&'a mut Delegate>, @@ -2156,9 +2152,9 @@ pub struct TaskListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TaskListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TaskListCall<'a, C, A> {} -impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TaskListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2291,7 +2287,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The project under which the queue lies. - pub fn project(mut self, new_value: &str) -> TaskListCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TaskListCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2301,7 +2297,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// The id of the taskqueue to list tasks from. - pub fn taskqueue(mut self, new_value: &str) -> TaskListCall<'a, C, NC, A> { + pub fn taskqueue(mut self, new_value: &str) -> TaskListCall<'a, C, A> { self._taskqueue = new_value.to_string(); self } @@ -2312,7 +2308,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2333,7 +2329,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TaskListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TaskListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2350,7 +2346,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TaskListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TaskListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2388,10 +2384,10 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct TaskGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TaskGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Taskqueue, + hub: &'a Taskqueue, _project: String, _taskqueue: String, _task: String, @@ -2400,9 +2396,9 @@ pub struct TaskGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TaskGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TaskGetCall<'a, C, A> {} -impl<'a, C, NC, A> TaskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TaskGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2536,7 +2532,7 @@ impl<'a, C, NC, A> TaskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// The project under which the queue lies. - pub fn project(mut self, new_value: &str) -> TaskGetCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TaskGetCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2546,7 +2542,7 @@ impl<'a, C, NC, A> TaskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// The taskqueue in which the task belongs. - pub fn taskqueue(mut self, new_value: &str) -> TaskGetCall<'a, C, NC, A> { + pub fn taskqueue(mut self, new_value: &str) -> TaskGetCall<'a, C, A> { self._taskqueue = new_value.to_string(); self } @@ -2556,7 +2552,7 @@ impl<'a, C, NC, A> TaskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// The task to get properties of. - pub fn task(mut self, new_value: &str) -> TaskGetCall<'a, C, NC, A> { + pub fn task(mut self, new_value: &str) -> TaskGetCall<'a, C, A> { self._task = new_value.to_string(); self } @@ -2567,7 +2563,7 @@ impl<'a, C, NC, A> TaskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2588,7 +2584,7 @@ impl<'a, C, NC, A> TaskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TaskGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TaskGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2605,7 +2601,7 @@ impl<'a, C, NC, A> TaskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TaskGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TaskGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2649,10 +2645,10 @@ impl<'a, C, NC, A> TaskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct TaskUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TaskUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Taskqueue, + hub: &'a Taskqueue, _request: Task, _project: String, _taskqueue: String, @@ -2663,9 +2659,9 @@ pub struct TaskUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TaskUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TaskUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> TaskUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TaskUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2807,7 +2803,7 @@ impl<'a, C, NC, A> TaskUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Task) -> TaskUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Task) -> TaskUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2817,7 +2813,7 @@ impl<'a, C, NC, A> TaskUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The project under which the queue lies. - pub fn project(mut self, new_value: &str) -> TaskUpdateCall<'a, C, NC, A> { + pub fn project(mut self, new_value: &str) -> TaskUpdateCall<'a, C, A> { self._project = new_value.to_string(); self } @@ -2826,7 +2822,7 @@ impl<'a, C, NC, A> TaskUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn taskqueue(mut self, new_value: &str) -> TaskUpdateCall<'a, C, NC, A> { + pub fn taskqueue(mut self, new_value: &str) -> TaskUpdateCall<'a, C, A> { self._taskqueue = new_value.to_string(); self } @@ -2835,7 +2831,7 @@ impl<'a, C, NC, A> TaskUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn task(mut self, new_value: &str) -> TaskUpdateCall<'a, C, NC, A> { + pub fn task(mut self, new_value: &str) -> TaskUpdateCall<'a, C, A> { self._task = new_value.to_string(); self } @@ -2845,7 +2841,7 @@ impl<'a, C, NC, A> TaskUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The new lease in seconds. - pub fn new_lease_seconds(mut self, new_value: i32) -> TaskUpdateCall<'a, C, NC, A> { + pub fn new_lease_seconds(mut self, new_value: i32) -> TaskUpdateCall<'a, C, A> { self._new_lease_seconds = new_value; self } @@ -2856,7 +2852,7 @@ impl<'a, C, NC, A> TaskUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2877,7 +2873,7 @@ impl<'a, C, NC, A> TaskUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TaskUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TaskUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2894,7 +2890,7 @@ impl<'a, C, NC, A> TaskUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TaskUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TaskUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/tasks1/Cargo.toml b/gen/tasks1/Cargo.toml index 06e79a31b3e..626ed757690 100644 --- a/gen/tasks1/Cargo.toml +++ b/gen/tasks1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-tasks1" -version = "0.1.4+20141121" +version = "0.1.5+20141121" authors = ["Sebastian Thiel "] description = "A complete library to interact with tasks (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/tasks1" homepage = "https://developers.google.com/google-apps/tasks/firstapp" -documentation = "http://byron.github.io/google-apis-rs/google-tasks1" +documentation = "http://byron.github.io/google-apis-rs/google_tasks1" license = "MIT" keywords = ["tasks", "google", "protocol", "web", "api"] diff --git a/gen/tasks1/README.md b/gen/tasks1/README.md index 734ab777c7e..0fdbfb36008 100644 --- a/gen/tasks1/README.md +++ b/gen/tasks1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-tasks1` library allows access to all features of the *Google tasks* service. -This documentation was generated from *tasks* crate version *0.1.4+20141121*, where *20141121* is the exact revision of the *tasks:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *tasks* crate version *0.1.5+20141121*, where *20141121* is the exact revision of the *tasks:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *tasks* *v1* API can be found at the [official documentation site](https://developers.google.com/google-apps/tasks/firstapp). diff --git a/gen/tasks1/src/cmn.rs b/gen/tasks1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/tasks1/src/cmn.rs +++ b/gen/tasks1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/tasks1/src/lib.rs b/gen/tasks1/src/lib.rs index d8606cb3bad..be4604ad0e0 100644 --- a/gen/tasks1/src/lib.rs +++ b/gen/tasks1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *tasks* crate version *0.1.4+20141121*, where *20141121* is the exact revision of the *tasks:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *tasks* crate version *0.1.5+20141121*, where *20141121* is the exact revision of the *tasks:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *tasks* *v1* API can be found at the //! [official documentation site](https://developers.google.com/google-apps/tasks/firstapp). @@ -207,7 +207,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -312,37 +311,34 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct TasksHub { +pub struct TasksHub { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for TasksHub {} +impl<'a, C, A> Hub for TasksHub {} -impl<'a, C, NC, A> TasksHub - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TasksHub + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> TasksHub { + pub fn new(client: C, authenticator: A) -> TasksHub { TasksHub { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn tasklists(&'a self) -> TasklistMethods<'a, C, NC, A> { + pub fn tasklists(&'a self) -> TasklistMethods<'a, C, A> { TasklistMethods { hub: &self } } - pub fn tasks(&'a self) -> TaskMethods<'a, C, NC, A> { + pub fn tasks(&'a self) -> TaskMethods<'a, C, A> { TaskMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -548,15 +544,15 @@ impl ResponseResult for Tasks {} /// let rb = hub.tasks(); /// # } /// ``` -pub struct TaskMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TaskMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TasksHub, + hub: &'a TasksHub, } -impl<'a, C, NC, A> MethodsBuilder for TaskMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TaskMethods<'a, C, A> {} -impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { +impl<'a, C, A> TaskMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -565,7 +561,7 @@ impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { /// # Arguments /// /// * `tasklist` - Task list identifier. - pub fn list(&self, tasklist: &str) -> TaskListCall<'a, C, NC, A> { + pub fn list(&self, tasklist: &str) -> TaskListCall<'a, C, A> { TaskListCall { hub: self.hub, _tasklist: tasklist.to_string(), @@ -594,7 +590,7 @@ impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `tasklist` - Task list identifier. /// * `task` - Task identifier. - pub fn update(&self, request: &Task, tasklist: &str, task: &str) -> TaskUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Task, tasklist: &str, task: &str) -> TaskUpdateCall<'a, C, A> { TaskUpdateCall { hub: self.hub, _request: request.clone(), @@ -615,7 +611,7 @@ impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { /// * `request` - No description provided. /// * `tasklist` - Task list identifier. /// * `task` - Task identifier. - pub fn patch(&self, request: &Task, tasklist: &str, task: &str) -> TaskPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &Task, tasklist: &str, task: &str) -> TaskPatchCall<'a, C, A> { TaskPatchCall { hub: self.hub, _request: request.clone(), @@ -634,7 +630,7 @@ impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { /// # Arguments /// /// * `tasklist` - Task list identifier. - pub fn clear(&self, tasklist: &str) -> TaskClearCall<'a, C, NC, A> { + pub fn clear(&self, tasklist: &str) -> TaskClearCall<'a, C, A> { TaskClearCall { hub: self.hub, _tasklist: tasklist.to_string(), @@ -652,7 +648,7 @@ impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { /// /// * `tasklist` - Task list identifier. /// * `task` - Task identifier. - pub fn move_(&self, tasklist: &str, task: &str) -> TaskMoveCall<'a, C, NC, A> { + pub fn move_(&self, tasklist: &str, task: &str) -> TaskMoveCall<'a, C, A> { TaskMoveCall { hub: self.hub, _tasklist: tasklist.to_string(), @@ -673,7 +669,7 @@ impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { /// /// * `tasklist` - Task list identifier. /// * `task` - Task identifier. - pub fn delete(&self, tasklist: &str, task: &str) -> TaskDeleteCall<'a, C, NC, A> { + pub fn delete(&self, tasklist: &str, task: &str) -> TaskDeleteCall<'a, C, A> { TaskDeleteCall { hub: self.hub, _tasklist: tasklist.to_string(), @@ -692,7 +688,7 @@ impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { /// /// * `tasklist` - Task list identifier. /// * `task` - Task identifier. - pub fn get(&self, tasklist: &str, task: &str) -> TaskGetCall<'a, C, NC, A> { + pub fn get(&self, tasklist: &str, task: &str) -> TaskGetCall<'a, C, A> { TaskGetCall { hub: self.hub, _tasklist: tasklist.to_string(), @@ -711,7 +707,7 @@ impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `tasklist` - Task list identifier. - pub fn insert(&self, request: &Task, tasklist: &str) -> TaskInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Task, tasklist: &str) -> TaskInsertCall<'a, C, A> { TaskInsertCall { hub: self.hub, _request: request.clone(), @@ -755,20 +751,20 @@ impl<'a, C, NC, A> TaskMethods<'a, C, NC, A> { /// let rb = hub.tasklists(); /// # } /// ``` -pub struct TasklistMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TasklistMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TasksHub, + hub: &'a TasksHub, } -impl<'a, C, NC, A> MethodsBuilder for TasklistMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TasklistMethods<'a, C, A> {} -impl<'a, C, NC, A> TasklistMethods<'a, C, NC, A> { +impl<'a, C, A> TasklistMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Returns all the authenticated user's task lists. - pub fn list(&self) -> TasklistListCall<'a, C, NC, A> { + pub fn list(&self) -> TasklistListCall<'a, C, A> { TasklistListCall { hub: self.hub, _page_token: Default::default(), @@ -787,7 +783,7 @@ impl<'a, C, NC, A> TasklistMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `tasklist` - Task list identifier. - pub fn update(&self, request: &TaskList, tasklist: &str) -> TasklistUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &TaskList, tasklist: &str) -> TasklistUpdateCall<'a, C, A> { TasklistUpdateCall { hub: self.hub, _request: request.clone(), @@ -805,7 +801,7 @@ impl<'a, C, NC, A> TasklistMethods<'a, C, NC, A> { /// # Arguments /// /// * `tasklist` - Task list identifier. - pub fn delete(&self, tasklist: &str) -> TasklistDeleteCall<'a, C, NC, A> { + pub fn delete(&self, tasklist: &str) -> TasklistDeleteCall<'a, C, A> { TasklistDeleteCall { hub: self.hub, _tasklist: tasklist.to_string(), @@ -823,7 +819,7 @@ impl<'a, C, NC, A> TasklistMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `tasklist` - Task list identifier. - pub fn patch(&self, request: &TaskList, tasklist: &str) -> TasklistPatchCall<'a, C, NC, A> { + pub fn patch(&self, request: &TaskList, tasklist: &str) -> TasklistPatchCall<'a, C, A> { TasklistPatchCall { hub: self.hub, _request: request.clone(), @@ -841,7 +837,7 @@ impl<'a, C, NC, A> TasklistMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &TaskList) -> TasklistInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &TaskList) -> TasklistInsertCall<'a, C, A> { TasklistInsertCall { hub: self.hub, _request: request.clone(), @@ -858,7 +854,7 @@ impl<'a, C, NC, A> TasklistMethods<'a, C, NC, A> { /// # Arguments /// /// * `tasklist` - Task list identifier. - pub fn get(&self, tasklist: &str) -> TasklistGetCall<'a, C, NC, A> { + pub fn get(&self, tasklist: &str) -> TasklistGetCall<'a, C, A> { TasklistGetCall { hub: self.hub, _tasklist: tasklist.to_string(), @@ -917,10 +913,10 @@ impl<'a, C, NC, A> TasklistMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct TaskListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TaskListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TasksHub, + hub: &'a TasksHub, _tasklist: String, _updated_min: Option, _show_hidden: Option, @@ -937,9 +933,9 @@ pub struct TaskListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TaskListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TaskListCall<'a, C, A> {} -impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TaskListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1101,7 +1097,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Task list identifier. - pub fn tasklist(mut self, new_value: &str) -> TaskListCall<'a, C, NC, A> { + pub fn tasklist(mut self, new_value: &str) -> TaskListCall<'a, C, A> { self._tasklist = new_value.to_string(); self } @@ -1109,7 +1105,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Lower bound for a task's last modification time (as a RFC 3339 timestamp) to filter by. Optional. The default is not to filter by last modification time. - pub fn updated_min(mut self, new_value: &str) -> TaskListCall<'a, C, NC, A> { + pub fn updated_min(mut self, new_value: &str) -> TaskListCall<'a, C, A> { self._updated_min = Some(new_value.to_string()); self } @@ -1117,7 +1113,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Flag indicating whether hidden tasks are returned in the result. Optional. The default is False. - pub fn show_hidden(mut self, new_value: bool) -> TaskListCall<'a, C, NC, A> { + pub fn show_hidden(mut self, new_value: bool) -> TaskListCall<'a, C, A> { self._show_hidden = Some(new_value); self } @@ -1125,7 +1121,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Flag indicating whether deleted tasks are returned in the result. Optional. The default is False. - pub fn show_deleted(mut self, new_value: bool) -> TaskListCall<'a, C, NC, A> { + pub fn show_deleted(mut self, new_value: bool) -> TaskListCall<'a, C, A> { self._show_deleted = Some(new_value); self } @@ -1133,7 +1129,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Flag indicating whether completed tasks are returned in the result. Optional. The default is True. - pub fn show_completed(mut self, new_value: bool) -> TaskListCall<'a, C, NC, A> { + pub fn show_completed(mut self, new_value: bool) -> TaskListCall<'a, C, A> { self._show_completed = Some(new_value); self } @@ -1141,7 +1137,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Token specifying the result page to return. Optional. - pub fn page_token(mut self, new_value: &str) -> TaskListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TaskListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -1149,7 +1145,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Maximum number of task lists returned on one page. Optional. The default is 100. - pub fn max_results(mut self, new_value: &str) -> TaskListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: &str) -> TaskListCall<'a, C, A> { self._max_results = Some(new_value.to_string()); self } @@ -1157,7 +1153,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Lower bound for a task's due date (as a RFC 3339 timestamp) to filter by. Optional. The default is not to filter by due date. - pub fn due_min(mut self, new_value: &str) -> TaskListCall<'a, C, NC, A> { + pub fn due_min(mut self, new_value: &str) -> TaskListCall<'a, C, A> { self._due_min = Some(new_value.to_string()); self } @@ -1165,7 +1161,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Upper bound for a task's due date (as a RFC 3339 timestamp) to filter by. Optional. The default is not to filter by due date. - pub fn due_max(mut self, new_value: &str) -> TaskListCall<'a, C, NC, A> { + pub fn due_max(mut self, new_value: &str) -> TaskListCall<'a, C, A> { self._due_max = Some(new_value.to_string()); self } @@ -1173,7 +1169,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Lower bound for a task's completion date (as a RFC 3339 timestamp) to filter by. Optional. The default is not to filter by completion date. - pub fn completed_min(mut self, new_value: &str) -> TaskListCall<'a, C, NC, A> { + pub fn completed_min(mut self, new_value: &str) -> TaskListCall<'a, C, A> { self._completed_min = Some(new_value.to_string()); self } @@ -1181,7 +1177,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// Upper bound for a task's completion date (as a RFC 3339 timestamp) to filter by. Optional. The default is not to filter by completion date. - pub fn completed_max(mut self, new_value: &str) -> TaskListCall<'a, C, NC, A> { + pub fn completed_max(mut self, new_value: &str) -> TaskListCall<'a, C, A> { self._completed_max = Some(new_value.to_string()); self } @@ -1192,7 +1188,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1213,7 +1209,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TaskListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TaskListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1230,7 +1226,7 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TaskListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TaskListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1274,10 +1270,10 @@ impl<'a, C, NC, A> TaskListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct TaskUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TaskUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TasksHub, + hub: &'a TasksHub, _request: Task, _tasklist: String, _task: String, @@ -1286,9 +1282,9 @@ pub struct TaskUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TaskUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TaskUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> TaskUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TaskUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1428,7 +1424,7 @@ impl<'a, C, NC, A> TaskUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Task) -> TaskUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Task) -> TaskUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1438,7 +1434,7 @@ impl<'a, C, NC, A> TaskUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Task list identifier. - pub fn tasklist(mut self, new_value: &str) -> TaskUpdateCall<'a, C, NC, A> { + pub fn tasklist(mut self, new_value: &str) -> TaskUpdateCall<'a, C, A> { self._tasklist = new_value.to_string(); self } @@ -1448,7 +1444,7 @@ impl<'a, C, NC, A> TaskUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Task identifier. - pub fn task(mut self, new_value: &str) -> TaskUpdateCall<'a, C, NC, A> { + pub fn task(mut self, new_value: &str) -> TaskUpdateCall<'a, C, A> { self._task = new_value.to_string(); self } @@ -1459,7 +1455,7 @@ impl<'a, C, NC, A> TaskUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1480,7 +1476,7 @@ impl<'a, C, NC, A> TaskUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TaskUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TaskUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1497,7 +1493,7 @@ impl<'a, C, NC, A> TaskUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TaskUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TaskUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1541,10 +1537,10 @@ impl<'a, C, NC, A> TaskUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct TaskPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TaskPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TasksHub, + hub: &'a TasksHub, _request: Task, _tasklist: String, _task: String, @@ -1553,9 +1549,9 @@ pub struct TaskPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TaskPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TaskPatchCall<'a, C, A> {} -impl<'a, C, NC, A> TaskPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TaskPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1695,7 +1691,7 @@ impl<'a, C, NC, A> TaskPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Task) -> TaskPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Task) -> TaskPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1705,7 +1701,7 @@ impl<'a, C, NC, A> TaskPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Task list identifier. - pub fn tasklist(mut self, new_value: &str) -> TaskPatchCall<'a, C, NC, A> { + pub fn tasklist(mut self, new_value: &str) -> TaskPatchCall<'a, C, A> { self._tasklist = new_value.to_string(); self } @@ -1715,7 +1711,7 @@ impl<'a, C, NC, A> TaskPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Task identifier. - pub fn task(mut self, new_value: &str) -> TaskPatchCall<'a, C, NC, A> { + pub fn task(mut self, new_value: &str) -> TaskPatchCall<'a, C, A> { self._task = new_value.to_string(); self } @@ -1726,7 +1722,7 @@ impl<'a, C, NC, A> TaskPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1747,7 +1743,7 @@ impl<'a, C, NC, A> TaskPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TaskPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TaskPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1764,7 +1760,7 @@ impl<'a, C, NC, A> TaskPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TaskPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TaskPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1802,19 +1798,19 @@ impl<'a, C, NC, A> TaskPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct TaskClearCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TaskClearCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TasksHub, + hub: &'a TasksHub, _tasklist: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TaskClearCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TaskClearCall<'a, C, A> {} -impl<'a, C, NC, A> TaskClearCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TaskClearCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1935,7 +1931,7 @@ impl<'a, C, NC, A> TaskClearCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Task list identifier. - pub fn tasklist(mut self, new_value: &str) -> TaskClearCall<'a, C, NC, A> { + pub fn tasklist(mut self, new_value: &str) -> TaskClearCall<'a, C, A> { self._tasklist = new_value.to_string(); self } @@ -1946,7 +1942,7 @@ impl<'a, C, NC, A> TaskClearCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskClearCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskClearCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1967,7 +1963,7 @@ impl<'a, C, NC, A> TaskClearCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TaskClearCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TaskClearCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1984,7 +1980,7 @@ impl<'a, C, NC, A> TaskClearCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TaskClearCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TaskClearCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2024,10 +2020,10 @@ impl<'a, C, NC, A> TaskClearCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct TaskMoveCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TaskMoveCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TasksHub, + hub: &'a TasksHub, _tasklist: String, _task: String, _previous: Option, @@ -2037,9 +2033,9 @@ pub struct TaskMoveCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TaskMoveCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TaskMoveCall<'a, C, A> {} -impl<'a, C, NC, A> TaskMoveCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TaskMoveCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2178,7 +2174,7 @@ impl<'a, C, NC, A> TaskMoveCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Task list identifier. - pub fn tasklist(mut self, new_value: &str) -> TaskMoveCall<'a, C, NC, A> { + pub fn tasklist(mut self, new_value: &str) -> TaskMoveCall<'a, C, A> { self._tasklist = new_value.to_string(); self } @@ -2188,7 +2184,7 @@ impl<'a, C, NC, A> TaskMoveCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// we provide this method for API completeness. /// /// Task identifier. - pub fn task(mut self, new_value: &str) -> TaskMoveCall<'a, C, NC, A> { + pub fn task(mut self, new_value: &str) -> TaskMoveCall<'a, C, A> { self._task = new_value.to_string(); self } @@ -2196,7 +2192,7 @@ impl<'a, C, NC, A> TaskMoveCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// New previous sibling task identifier. If the task is moved to the first position among its siblings, this parameter is omitted. Optional. - pub fn previous(mut self, new_value: &str) -> TaskMoveCall<'a, C, NC, A> { + pub fn previous(mut self, new_value: &str) -> TaskMoveCall<'a, C, A> { self._previous = Some(new_value.to_string()); self } @@ -2204,7 +2200,7 @@ impl<'a, C, NC, A> TaskMoveCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// /// /// New parent task identifier. If the task is moved to the top level, this parameter is omitted. Optional. - pub fn parent(mut self, new_value: &str) -> TaskMoveCall<'a, C, NC, A> { + pub fn parent(mut self, new_value: &str) -> TaskMoveCall<'a, C, A> { self._parent = Some(new_value.to_string()); self } @@ -2215,7 +2211,7 @@ impl<'a, C, NC, A> TaskMoveCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskMoveCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskMoveCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2236,7 +2232,7 @@ impl<'a, C, NC, A> TaskMoveCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TaskMoveCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TaskMoveCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2253,7 +2249,7 @@ impl<'a, C, NC, A> TaskMoveCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TaskMoveCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TaskMoveCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2291,10 +2287,10 @@ impl<'a, C, NC, A> TaskMoveCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct TaskDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TaskDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TasksHub, + hub: &'a TasksHub, _tasklist: String, _task: String, _delegate: Option<&'a mut Delegate>, @@ -2302,9 +2298,9 @@ pub struct TaskDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TaskDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TaskDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> TaskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TaskDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2426,7 +2422,7 @@ impl<'a, C, NC, A> TaskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Task list identifier. - pub fn tasklist(mut self, new_value: &str) -> TaskDeleteCall<'a, C, NC, A> { + pub fn tasklist(mut self, new_value: &str) -> TaskDeleteCall<'a, C, A> { self._tasklist = new_value.to_string(); self } @@ -2436,7 +2432,7 @@ impl<'a, C, NC, A> TaskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Task identifier. - pub fn task(mut self, new_value: &str) -> TaskDeleteCall<'a, C, NC, A> { + pub fn task(mut self, new_value: &str) -> TaskDeleteCall<'a, C, A> { self._task = new_value.to_string(); self } @@ -2447,7 +2443,7 @@ impl<'a, C, NC, A> TaskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2468,7 +2464,7 @@ impl<'a, C, NC, A> TaskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TaskDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TaskDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2485,7 +2481,7 @@ impl<'a, C, NC, A> TaskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TaskDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TaskDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2523,10 +2519,10 @@ impl<'a, C, NC, A> TaskDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct TaskGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TaskGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TasksHub, + hub: &'a TasksHub, _tasklist: String, _task: String, _delegate: Option<&'a mut Delegate>, @@ -2534,9 +2530,9 @@ pub struct TaskGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TaskGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TaskGetCall<'a, C, A> {} -impl<'a, C, NC, A> TaskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TaskGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2669,7 +2665,7 @@ impl<'a, C, NC, A> TaskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// Task list identifier. - pub fn tasklist(mut self, new_value: &str) -> TaskGetCall<'a, C, NC, A> { + pub fn tasklist(mut self, new_value: &str) -> TaskGetCall<'a, C, A> { self._tasklist = new_value.to_string(); self } @@ -2679,7 +2675,7 @@ impl<'a, C, NC, A> TaskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// Task identifier. - pub fn task(mut self, new_value: &str) -> TaskGetCall<'a, C, NC, A> { + pub fn task(mut self, new_value: &str) -> TaskGetCall<'a, C, A> { self._task = new_value.to_string(); self } @@ -2690,7 +2686,7 @@ impl<'a, C, NC, A> TaskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2711,7 +2707,7 @@ impl<'a, C, NC, A> TaskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TaskGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TaskGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2728,7 +2724,7 @@ impl<'a, C, NC, A> TaskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TaskGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TaskGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2774,10 +2770,10 @@ impl<'a, C, NC, A> TaskGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct TaskInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TaskInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TasksHub, + hub: &'a TasksHub, _request: Task, _tasklist: String, _previous: Option, @@ -2787,9 +2783,9 @@ pub struct TaskInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TaskInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TaskInsertCall<'a, C, A> {} -impl<'a, C, NC, A> TaskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TaskInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2934,7 +2930,7 @@ impl<'a, C, NC, A> TaskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Task) -> TaskInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Task) -> TaskInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2944,7 +2940,7 @@ impl<'a, C, NC, A> TaskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// Task list identifier. - pub fn tasklist(mut self, new_value: &str) -> TaskInsertCall<'a, C, NC, A> { + pub fn tasklist(mut self, new_value: &str) -> TaskInsertCall<'a, C, A> { self._tasklist = new_value.to_string(); self } @@ -2952,7 +2948,7 @@ impl<'a, C, NC, A> TaskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Previous sibling task identifier. If the task is created at the first position among its siblings, this parameter is omitted. Optional. - pub fn previous(mut self, new_value: &str) -> TaskInsertCall<'a, C, NC, A> { + pub fn previous(mut self, new_value: &str) -> TaskInsertCall<'a, C, A> { self._previous = Some(new_value.to_string()); self } @@ -2960,7 +2956,7 @@ impl<'a, C, NC, A> TaskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// Parent task identifier. If the task is created at the top level, this parameter is omitted. Optional. - pub fn parent(mut self, new_value: &str) -> TaskInsertCall<'a, C, NC, A> { + pub fn parent(mut self, new_value: &str) -> TaskInsertCall<'a, C, A> { self._parent = Some(new_value.to_string()); self } @@ -2971,7 +2967,7 @@ impl<'a, C, NC, A> TaskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TaskInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2992,7 +2988,7 @@ impl<'a, C, NC, A> TaskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TaskInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TaskInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3009,7 +3005,7 @@ impl<'a, C, NC, A> TaskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TaskInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TaskInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3049,10 +3045,10 @@ impl<'a, C, NC, A> TaskInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct TasklistListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TasklistListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TasksHub, + hub: &'a TasksHub, _page_token: Option, _max_results: Option, _delegate: Option<&'a mut Delegate>, @@ -3060,9 +3056,9 @@ pub struct TasklistListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TasklistListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TasklistListCall<'a, C, A> {} -impl<'a, C, NC, A> TasklistListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TasklistListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3173,7 +3169,7 @@ impl<'a, C, NC, A> TasklistListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Token specifying the result page to return. Optional. - pub fn page_token(mut self, new_value: &str) -> TasklistListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> TasklistListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -3181,7 +3177,7 @@ impl<'a, C, NC, A> TasklistListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Maximum number of task lists returned on one page. Optional. The default is 100. - pub fn max_results(mut self, new_value: &str) -> TasklistListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: &str) -> TasklistListCall<'a, C, A> { self._max_results = Some(new_value.to_string()); self } @@ -3192,7 +3188,7 @@ impl<'a, C, NC, A> TasklistListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TasklistListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TasklistListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3213,7 +3209,7 @@ impl<'a, C, NC, A> TasklistListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TasklistListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TasklistListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3230,7 +3226,7 @@ impl<'a, C, NC, A> TasklistListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TasklistListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TasklistListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3274,10 +3270,10 @@ impl<'a, C, NC, A> TasklistListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct TasklistUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TasklistUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TasksHub, + hub: &'a TasksHub, _request: TaskList, _tasklist: String, _delegate: Option<&'a mut Delegate>, @@ -3285,9 +3281,9 @@ pub struct TasklistUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TasklistUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TasklistUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> TasklistUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TasklistUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3426,7 +3422,7 @@ impl<'a, C, NC, A> TasklistUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &TaskList) -> TasklistUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &TaskList) -> TasklistUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3436,7 +3432,7 @@ impl<'a, C, NC, A> TasklistUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Task list identifier. - pub fn tasklist(mut self, new_value: &str) -> TasklistUpdateCall<'a, C, NC, A> { + pub fn tasklist(mut self, new_value: &str) -> TasklistUpdateCall<'a, C, A> { self._tasklist = new_value.to_string(); self } @@ -3447,7 +3443,7 @@ impl<'a, C, NC, A> TasklistUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TasklistUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TasklistUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3468,7 +3464,7 @@ impl<'a, C, NC, A> TasklistUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TasklistUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TasklistUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3485,7 +3481,7 @@ impl<'a, C, NC, A> TasklistUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TasklistUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TasklistUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3523,19 +3519,19 @@ impl<'a, C, NC, A> TasklistUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct TasklistDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TasklistDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TasksHub, + hub: &'a TasksHub, _tasklist: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TasklistDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TasklistDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> TasklistDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TasklistDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3656,7 +3652,7 @@ impl<'a, C, NC, A> TasklistDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// Task list identifier. - pub fn tasklist(mut self, new_value: &str) -> TasklistDeleteCall<'a, C, NC, A> { + pub fn tasklist(mut self, new_value: &str) -> TasklistDeleteCall<'a, C, A> { self._tasklist = new_value.to_string(); self } @@ -3667,7 +3663,7 @@ impl<'a, C, NC, A> TasklistDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TasklistDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TasklistDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3688,7 +3684,7 @@ impl<'a, C, NC, A> TasklistDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TasklistDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TasklistDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3705,7 +3701,7 @@ impl<'a, C, NC, A> TasklistDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TasklistDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TasklistDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3749,10 +3745,10 @@ impl<'a, C, NC, A> TasklistDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct TasklistPatchCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TasklistPatchCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TasksHub, + hub: &'a TasksHub, _request: TaskList, _tasklist: String, _delegate: Option<&'a mut Delegate>, @@ -3760,9 +3756,9 @@ pub struct TasklistPatchCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TasklistPatchCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TasklistPatchCall<'a, C, A> {} -impl<'a, C, NC, A> TasklistPatchCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TasklistPatchCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3901,7 +3897,7 @@ impl<'a, C, NC, A> TasklistPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &TaskList) -> TasklistPatchCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &TaskList) -> TasklistPatchCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3911,7 +3907,7 @@ impl<'a, C, NC, A> TasklistPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// Task list identifier. - pub fn tasklist(mut self, new_value: &str) -> TasklistPatchCall<'a, C, NC, A> { + pub fn tasklist(mut self, new_value: &str) -> TasklistPatchCall<'a, C, A> { self._tasklist = new_value.to_string(); self } @@ -3922,7 +3918,7 @@ impl<'a, C, NC, A> TasklistPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TasklistPatchCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TasklistPatchCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3943,7 +3939,7 @@ impl<'a, C, NC, A> TasklistPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TasklistPatchCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TasklistPatchCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3960,7 +3956,7 @@ impl<'a, C, NC, A> TasklistPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TasklistPatchCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TasklistPatchCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4004,19 +4000,19 @@ impl<'a, C, NC, A> TasklistPatchCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct TasklistInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TasklistInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TasksHub, + hub: &'a TasksHub, _request: TaskList, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TasklistInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TasklistInsertCall<'a, C, A> {} -impl<'a, C, NC, A> TasklistInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TasklistInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4130,7 +4126,7 @@ impl<'a, C, NC, A> TasklistInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &TaskList) -> TasklistInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &TaskList) -> TasklistInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -4141,7 +4137,7 @@ impl<'a, C, NC, A> TasklistInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TasklistInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TasklistInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4162,7 +4158,7 @@ impl<'a, C, NC, A> TasklistInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TasklistInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TasklistInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4179,7 +4175,7 @@ impl<'a, C, NC, A> TasklistInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TasklistInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TasklistInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -4217,19 +4213,19 @@ impl<'a, C, NC, A> TasklistInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct TasklistGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TasklistGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a TasksHub, + hub: &'a TasksHub, _tasklist: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for TasklistGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TasklistGetCall<'a, C, A> {} -impl<'a, C, NC, A> TasklistGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TasklistGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -4361,7 +4357,7 @@ impl<'a, C, NC, A> TasklistGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// Task list identifier. - pub fn tasklist(mut self, new_value: &str) -> TasklistGetCall<'a, C, NC, A> { + pub fn tasklist(mut self, new_value: &str) -> TasklistGetCall<'a, C, A> { self._tasklist = new_value.to_string(); self } @@ -4372,7 +4368,7 @@ impl<'a, C, NC, A> TasklistGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TasklistGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TasklistGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -4393,7 +4389,7 @@ impl<'a, C, NC, A> TasklistGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TasklistGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TasklistGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -4410,7 +4406,7 @@ impl<'a, C, NC, A> TasklistGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> TasklistGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> TasklistGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/translate2/Cargo.toml b/gen/translate2/Cargo.toml index 623b8abafe9..941f32025aa 100644 --- a/gen/translate2/Cargo.toml +++ b/gen/translate2/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-translate2" -version = "0.1.4+20141123" +version = "0.1.5+20141123" authors = ["Sebastian Thiel "] description = "A complete library to interact with translate (protocol v2)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/translate2" homepage = "https://developers.google.com/translate/v2/using_rest" -documentation = "http://byron.github.io/google-apis-rs/google-translate2" +documentation = "http://byron.github.io/google-apis-rs/google_translate2" license = "MIT" keywords = ["translate", "google", "protocol", "web", "api"] diff --git a/gen/translate2/README.md b/gen/translate2/README.md index 8a30673def6..0970f615e4c 100644 --- a/gen/translate2/README.md +++ b/gen/translate2/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-translate2` library allows access to all features of the *Google translate* service. -This documentation was generated from *translate* crate version *0.1.4+20141123*, where *20141123* is the exact revision of the *translate:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *translate* crate version *0.1.5+20141123*, where *20141123* is the exact revision of the *translate:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *translate* *v2* API can be found at the [official documentation site](https://developers.google.com/translate/v2/using_rest). diff --git a/gen/translate2/src/cmn.rs b/gen/translate2/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/translate2/src/cmn.rs +++ b/gen/translate2/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/translate2/src/lib.rs b/gen/translate2/src/lib.rs index 11a4187aae5..e1ea7725a50 100644 --- a/gen/translate2/src/lib.rs +++ b/gen/translate2/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *translate* crate version *0.1.4+20141123*, where *20141123* is the exact revision of the *translate:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *translate* crate version *0.1.5+20141123*, where *20141123* is the exact revision of the *translate:v2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *translate* *v2* API can be found at the //! [official documentation site](https://developers.google.com/translate/v2/using_rest). @@ -192,7 +192,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -261,40 +260,37 @@ pub use cmn::{MultiPartReader, ToParts, MethodInfo, Result, Error, CallBuilder, /// } /// # } /// ``` -pub struct Translate { +pub struct Translate { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Translate {} +impl<'a, C, A> Hub for Translate {} -impl<'a, C, NC, A> Translate - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Translate + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Translate { + pub fn new(client: C, authenticator: A) -> Translate { Translate { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn detections(&'a self) -> DetectionMethods<'a, C, NC, A> { + pub fn detections(&'a self) -> DetectionMethods<'a, C, A> { DetectionMethods { hub: &self } } - pub fn languages(&'a self) -> LanguageMethods<'a, C, NC, A> { + pub fn languages(&'a self) -> LanguageMethods<'a, C, A> { LanguageMethods { hub: &self } } - pub fn translations(&'a self) -> TranslationMethods<'a, C, NC, A> { + pub fn translations(&'a self) -> TranslationMethods<'a, C, A> { TranslationMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -466,20 +462,20 @@ impl ResponseResult for TranslationsListResponse {} /// let rb = hub.languages(); /// # } /// ``` -pub struct LanguageMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LanguageMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Translate, + hub: &'a Translate, } -impl<'a, C, NC, A> MethodsBuilder for LanguageMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for LanguageMethods<'a, C, A> {} -impl<'a, C, NC, A> LanguageMethods<'a, C, NC, A> { +impl<'a, C, A> LanguageMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// List the source/target languages supported by the API - pub fn list(&self) -> LanguageListCall<'a, C, NC, A> { + pub fn list(&self) -> LanguageListCall<'a, C, A> { LanguageListCall { hub: self.hub, _target: Default::default(), @@ -519,15 +515,15 @@ impl<'a, C, NC, A> LanguageMethods<'a, C, NC, A> { /// let rb = hub.detections(); /// # } /// ``` -pub struct DetectionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DetectionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Translate, + hub: &'a Translate, } -impl<'a, C, NC, A> MethodsBuilder for DetectionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for DetectionMethods<'a, C, A> {} -impl<'a, C, NC, A> DetectionMethods<'a, C, NC, A> { +impl<'a, C, A> DetectionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -536,7 +532,7 @@ impl<'a, C, NC, A> DetectionMethods<'a, C, NC, A> { /// # Arguments /// /// * `q` - The text to detect - pub fn list(&self, q: &Vec) -> DetectionListCall<'a, C, NC, A> { + pub fn list(&self, q: &Vec) -> DetectionListCall<'a, C, A> { DetectionListCall { hub: self.hub, _q: q.clone(), @@ -576,15 +572,15 @@ impl<'a, C, NC, A> DetectionMethods<'a, C, NC, A> { /// let rb = hub.translations(); /// # } /// ``` -pub struct TranslationMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TranslationMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Translate, + hub: &'a Translate, } -impl<'a, C, NC, A> MethodsBuilder for TranslationMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for TranslationMethods<'a, C, A> {} -impl<'a, C, NC, A> TranslationMethods<'a, C, NC, A> { +impl<'a, C, A> TranslationMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -594,7 +590,7 @@ impl<'a, C, NC, A> TranslationMethods<'a, C, NC, A> { /// /// * `q` - The text to translate /// * `target` - The target language into which the text should be translated - pub fn list(&self, q: &Vec, target: &str) -> TranslationListCall<'a, C, NC, A> { + pub fn list(&self, q: &Vec, target: &str) -> TranslationListCall<'a, C, A> { TranslationListCall { hub: self.hub, _q: q.clone(), @@ -647,18 +643,18 @@ impl<'a, C, NC, A> TranslationMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct LanguageListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LanguageListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Translate, + hub: &'a Translate, _target: Option, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for LanguageListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LanguageListCall<'a, C, A> {} -impl<'a, C, NC, A> LanguageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LanguageListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -764,7 +760,7 @@ impl<'a, C, NC, A> LanguageListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// the language and collation in which the localized results should be returned - pub fn target(mut self, new_value: &str) -> LanguageListCall<'a, C, NC, A> { + pub fn target(mut self, new_value: &str) -> LanguageListCall<'a, C, A> { self._target = Some(new_value.to_string()); self } @@ -775,7 +771,7 @@ impl<'a, C, NC, A> LanguageListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LanguageListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LanguageListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -796,7 +792,7 @@ impl<'a, C, NC, A> LanguageListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LanguageListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LanguageListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -835,18 +831,18 @@ impl<'a, C, NC, A> LanguageListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct DetectionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct DetectionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Translate, + hub: &'a Translate, _q: Vec, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for DetectionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for DetectionListCall<'a, C, A> {} -impl<'a, C, NC, A> DetectionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> DetectionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -959,7 +955,7 @@ impl<'a, C, NC, A> DetectionListCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The text to detect - pub fn add_q(mut self, new_value: &str) -> DetectionListCall<'a, C, NC, A> { + pub fn add_q(mut self, new_value: &str) -> DetectionListCall<'a, C, A> { self._q.push(new_value.to_string()); self } @@ -970,7 +966,7 @@ impl<'a, C, NC, A> DetectionListCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> DetectionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> DetectionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -991,7 +987,7 @@ impl<'a, C, NC, A> DetectionListCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> DetectionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> DetectionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1033,10 +1029,10 @@ impl<'a, C, NC, A> DetectionListCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct TranslationListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct TranslationListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Translate, + hub: &'a Translate, _q: Vec, _target: String, _source: Option, @@ -1046,9 +1042,9 @@ pub struct TranslationListCall<'a, C, NC, A> _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for TranslationListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for TranslationListCall<'a, C, A> {} -impl<'a, C, NC, A> TranslationListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> TranslationListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1175,7 +1171,7 @@ impl<'a, C, NC, A> TranslationListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The text to translate - pub fn add_q(mut self, new_value: &str) -> TranslationListCall<'a, C, NC, A> { + pub fn add_q(mut self, new_value: &str) -> TranslationListCall<'a, C, A> { self._q.push(new_value.to_string()); self } @@ -1185,7 +1181,7 @@ impl<'a, C, NC, A> TranslationListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The target language into which the text should be translated - pub fn target(mut self, new_value: &str) -> TranslationListCall<'a, C, NC, A> { + pub fn target(mut self, new_value: &str) -> TranslationListCall<'a, C, A> { self._target = new_value.to_string(); self } @@ -1193,7 +1189,7 @@ impl<'a, C, NC, A> TranslationListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The source language of the text - pub fn source(mut self, new_value: &str) -> TranslationListCall<'a, C, NC, A> { + pub fn source(mut self, new_value: &str) -> TranslationListCall<'a, C, A> { self._source = Some(new_value.to_string()); self } @@ -1201,7 +1197,7 @@ impl<'a, C, NC, A> TranslationListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The format of the text - pub fn format(mut self, new_value: &str) -> TranslationListCall<'a, C, NC, A> { + pub fn format(mut self, new_value: &str) -> TranslationListCall<'a, C, A> { self._format = Some(new_value.to_string()); self } @@ -1210,7 +1206,7 @@ impl<'a, C, NC, A> TranslationListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The customization id for translate - pub fn add_cid(mut self, new_value: &str) -> TranslationListCall<'a, C, NC, A> { + pub fn add_cid(mut self, new_value: &str) -> TranslationListCall<'a, C, A> { self._cid.push(new_value.to_string()); self } @@ -1221,7 +1217,7 @@ impl<'a, C, NC, A> TranslationListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> TranslationListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> TranslationListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1242,7 +1238,7 @@ impl<'a, C, NC, A> TranslationListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> TranslationListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> TranslationListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self diff --git a/gen/urlshortener1/Cargo.toml b/gen/urlshortener1/Cargo.toml index e4efc7a66f8..15281ab5ee8 100644 --- a/gen/urlshortener1/Cargo.toml +++ b/gen/urlshortener1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-urlshortener1" -version = "0.1.4+20150319" +version = "0.1.5+20150319" authors = ["Sebastian Thiel "] description = "A complete library to interact with urlshortener (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/urlshortener1" homepage = "https://developers.google.com/url-shortener/v1/getting_started" -documentation = "http://byron.github.io/google-apis-rs/google-urlshortener1" +documentation = "http://byron.github.io/google-apis-rs/google_urlshortener1" license = "MIT" keywords = ["urlshortener", "google", "protocol", "web", "api"] diff --git a/gen/urlshortener1/README.md b/gen/urlshortener1/README.md index 323fa47a999..5b8fe53df9d 100644 --- a/gen/urlshortener1/README.md +++ b/gen/urlshortener1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-urlshortener1` library allows access to all features of the *Google urlshortener* service. -This documentation was generated from *urlshortener* crate version *0.1.4+20150319*, where *20150319* is the exact revision of the *urlshortener:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *urlshortener* crate version *0.1.5+20150319*, where *20150319* is the exact revision of the *urlshortener:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *urlshortener* *v1* API can be found at the [official documentation site](https://developers.google.com/url-shortener/v1/getting_started). diff --git a/gen/urlshortener1/src/cmn.rs b/gen/urlshortener1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/urlshortener1/src/cmn.rs +++ b/gen/urlshortener1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/urlshortener1/src/lib.rs b/gen/urlshortener1/src/lib.rs index cd9778951c3..55e50bb204b 100644 --- a/gen/urlshortener1/src/lib.rs +++ b/gen/urlshortener1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *urlshortener* crate version *0.1.4+20150319*, where *20150319* is the exact revision of the *urlshortener:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *urlshortener* crate version *0.1.5+20150319*, where *20150319* is the exact revision of the *urlshortener:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *urlshortener* *v1* API can be found at the //! [official documentation site](https://developers.google.com/url-shortener/v1/getting_started). @@ -190,7 +190,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -282,34 +281,31 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Urlshortener { +pub struct Urlshortener { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Urlshortener {} +impl<'a, C, A> Hub for Urlshortener {} -impl<'a, C, NC, A> Urlshortener - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Urlshortener + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Urlshortener { + pub fn new(client: C, authenticator: A) -> Urlshortener { Urlshortener { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn url(&'a self) -> UrlMethods<'a, C, NC, A> { + pub fn url(&'a self) -> UrlMethods<'a, C, A> { UrlMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -479,15 +475,15 @@ impl Part for StringCount {} /// let rb = hub.url(); /// # } /// ``` -pub struct UrlMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Urlshortener, + hub: &'a Urlshortener, } -impl<'a, C, NC, A> MethodsBuilder for UrlMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for UrlMethods<'a, C, A> {} -impl<'a, C, NC, A> UrlMethods<'a, C, NC, A> { +impl<'a, C, A> UrlMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -496,7 +492,7 @@ impl<'a, C, NC, A> UrlMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &Url) -> UrlInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Url) -> UrlInsertCall<'a, C, A> { UrlInsertCall { hub: self.hub, _request: request.clone(), @@ -513,7 +509,7 @@ impl<'a, C, NC, A> UrlMethods<'a, C, NC, A> { /// # Arguments /// /// * `shortUrl` - The short URL, including the protocol. - pub fn get(&self, short_url: &str) -> UrlGetCall<'a, C, NC, A> { + pub fn get(&self, short_url: &str) -> UrlGetCall<'a, C, A> { UrlGetCall { hub: self.hub, _short_url: short_url.to_string(), @@ -527,7 +523,7 @@ impl<'a, C, NC, A> UrlMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Retrieves a list of URLs shortened by a user. - pub fn list(&self) -> UrlListCall<'a, C, NC, A> { + pub fn list(&self) -> UrlListCall<'a, C, A> { UrlListCall { hub: self.hub, _start_token: Default::default(), @@ -583,19 +579,19 @@ impl<'a, C, NC, A> UrlMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct UrlInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Urlshortener, + hub: &'a Urlshortener, _request: Url, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UrlInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UrlInsertCall<'a, C, A> {} -impl<'a, C, NC, A> UrlInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UrlInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -709,7 +705,7 @@ impl<'a, C, NC, A> UrlInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Url) -> UrlInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Url) -> UrlInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -720,7 +716,7 @@ impl<'a, C, NC, A> UrlInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -741,7 +737,7 @@ impl<'a, C, NC, A> UrlInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UrlInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UrlInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -758,7 +754,7 @@ impl<'a, C, NC, A> UrlInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UrlInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UrlInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -797,10 +793,10 @@ impl<'a, C, NC, A> UrlInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct UrlGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Urlshortener, + hub: &'a Urlshortener, _short_url: String, _projection: Option, _delegate: Option<&'a mut Delegate>, @@ -808,9 +804,9 @@ pub struct UrlGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UrlGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UrlGetCall<'a, C, A> {} -impl<'a, C, NC, A> UrlGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UrlGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -921,7 +917,7 @@ impl<'a, C, NC, A> UrlGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// we provide this method for API completeness. /// /// The short URL, including the protocol. - pub fn short_url(mut self, new_value: &str) -> UrlGetCall<'a, C, NC, A> { + pub fn short_url(mut self, new_value: &str) -> UrlGetCall<'a, C, A> { self._short_url = new_value.to_string(); self } @@ -929,7 +925,7 @@ impl<'a, C, NC, A> UrlGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// /// /// Additional information to return. - pub fn projection(mut self, new_value: &str) -> UrlGetCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> UrlGetCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -940,7 +936,7 @@ impl<'a, C, NC, A> UrlGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -961,7 +957,7 @@ impl<'a, C, NC, A> UrlGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UrlGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UrlGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -978,7 +974,7 @@ impl<'a, C, NC, A> UrlGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UrlGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UrlGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1018,10 +1014,10 @@ impl<'a, C, NC, A> UrlGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnect /// .doit(); /// # } /// ``` -pub struct UrlListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Urlshortener, + hub: &'a Urlshortener, _start_token: Option, _projection: Option, _delegate: Option<&'a mut Delegate>, @@ -1029,9 +1025,9 @@ pub struct UrlListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UrlListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UrlListCall<'a, C, A> {} -impl<'a, C, NC, A> UrlListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UrlListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1142,7 +1138,7 @@ impl<'a, C, NC, A> UrlListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Token for requesting successive pages of results. - pub fn start_token(mut self, new_value: &str) -> UrlListCall<'a, C, NC, A> { + pub fn start_token(mut self, new_value: &str) -> UrlListCall<'a, C, A> { self._start_token = Some(new_value.to_string()); self } @@ -1150,7 +1146,7 @@ impl<'a, C, NC, A> UrlListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// /// /// Additional information to return. - pub fn projection(mut self, new_value: &str) -> UrlListCall<'a, C, NC, A> { + pub fn projection(mut self, new_value: &str) -> UrlListCall<'a, C, A> { self._projection = Some(new_value.to_string()); self } @@ -1161,7 +1157,7 @@ impl<'a, C, NC, A> UrlListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1182,7 +1178,7 @@ impl<'a, C, NC, A> UrlListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UrlListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UrlListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1199,7 +1195,7 @@ impl<'a, C, NC, A> UrlListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UrlListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UrlListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/webfonts1/Cargo.toml b/gen/webfonts1/Cargo.toml index abe74baa0cf..09acf622b27 100644 --- a/gen/webfonts1/Cargo.toml +++ b/gen/webfonts1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-webfonts1" -version = "0.1.4+20140210" +version = "0.1.5+20140210" authors = ["Sebastian Thiel "] description = "A complete library to interact with webfonts (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/webfonts1" homepage = "https://developers.google.com/fonts/docs/developer_api" -documentation = "http://byron.github.io/google-apis-rs/google-webfonts1" +documentation = "http://byron.github.io/google-apis-rs/google_webfonts1" license = "MIT" keywords = ["webfonts", "google", "protocol", "web", "api"] diff --git a/gen/webfonts1/README.md b/gen/webfonts1/README.md index 81698e3e738..207b0cd9dca 100644 --- a/gen/webfonts1/README.md +++ b/gen/webfonts1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-webfonts1` library allows access to all features of the *Google webfonts* service. -This documentation was generated from *webfonts* crate version *0.1.4+20140210*, where *20140210* is the exact revision of the *webfonts:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *webfonts* crate version *0.1.5+20140210*, where *20140210* is the exact revision of the *webfonts:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *webfonts* *v1* API can be found at the [official documentation site](https://developers.google.com/fonts/docs/developer_api). diff --git a/gen/webfonts1/src/cmn.rs b/gen/webfonts1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/webfonts1/src/cmn.rs +++ b/gen/webfonts1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/webfonts1/src/lib.rs b/gen/webfonts1/src/lib.rs index 35628eb44a6..a561d617a51 100644 --- a/gen/webfonts1/src/lib.rs +++ b/gen/webfonts1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *webfonts* crate version *0.1.4+20140210*, where *20140210* is the exact revision of the *webfonts:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *webfonts* crate version *0.1.5+20140210*, where *20140210* is the exact revision of the *webfonts:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *webfonts* *v1* API can be found at the //! [official documentation site](https://developers.google.com/fonts/docs/developer_api). @@ -189,7 +189,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -259,34 +258,31 @@ pub use cmn::{MultiPartReader, ToParts, MethodInfo, Result, Error, CallBuilder, /// } /// # } /// ``` -pub struct Webfonts { +pub struct Webfonts { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Webfonts {} +impl<'a, C, A> Hub for Webfonts {} -impl<'a, C, NC, A> Webfonts - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Webfonts + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Webfonts { + pub fn new(client: C, authenticator: A) -> Webfonts { Webfonts { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn webfonts(&'a self) -> WebfontMethods<'a, C, NC, A> { + pub fn webfonts(&'a self) -> WebfontMethods<'a, C, A> { WebfontMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -386,20 +382,20 @@ impl ResponseResult for WebfontList {} /// let rb = hub.webfonts(); /// # } /// ``` -pub struct WebfontMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct WebfontMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Webfonts, + hub: &'a Webfonts, } -impl<'a, C, NC, A> MethodsBuilder for WebfontMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for WebfontMethods<'a, C, A> {} -impl<'a, C, NC, A> WebfontMethods<'a, C, NC, A> { +impl<'a, C, A> WebfontMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// /// Retrieves the list of fonts currently served by the Google Fonts Developer API - pub fn list(&self) -> WebfontListCall<'a, C, NC, A> { + pub fn list(&self) -> WebfontListCall<'a, C, A> { WebfontListCall { hub: self.hub, _sort: Default::default(), @@ -448,18 +444,18 @@ impl<'a, C, NC, A> WebfontMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct WebfontListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct WebfontListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Webfonts, + hub: &'a Webfonts, _sort: Option, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, } -impl<'a, C, NC, A> CallBuilder for WebfontListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for WebfontListCall<'a, C, A> {} -impl<'a, C, NC, A> WebfontListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> WebfontListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -565,7 +561,7 @@ impl<'a, C, NC, A> WebfontListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Enables sorting of the list - pub fn sort(mut self, new_value: &str) -> WebfontListCall<'a, C, NC, A> { + pub fn sort(mut self, new_value: &str) -> WebfontListCall<'a, C, A> { self._sort = Some(new_value.to_string()); self } @@ -576,7 +572,7 @@ impl<'a, C, NC, A> WebfontListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> WebfontListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> WebfontListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -597,7 +593,7 @@ impl<'a, C, NC, A> WebfontListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> WebfontListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> WebfontListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self diff --git a/gen/webmasters3/Cargo.toml b/gen/webmasters3/Cargo.toml index c39ca699828..05ad4df772c 100644 --- a/gen/webmasters3/Cargo.toml +++ b/gen/webmasters3/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-webmasters3" -version = "0.1.4+20140908" +version = "0.1.5+20140908" authors = ["Sebastian Thiel "] description = "A complete library to interact with webmasters (protocol v3)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/webmasters3" homepage = "https://developers.google.com/webmaster-tools/v3/welcome" -documentation = "http://byron.github.io/google-apis-rs/google-webmasters3" +documentation = "http://byron.github.io/google-apis-rs/google_webmasters3" license = "MIT" keywords = ["webmasters", "google", "protocol", "web", "api"] diff --git a/gen/webmasters3/README.md b/gen/webmasters3/README.md index 8b34c3842d4..d47b9b80978 100644 --- a/gen/webmasters3/README.md +++ b/gen/webmasters3/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-webmasters3` library allows access to all features of the *Google webmasters* service. -This documentation was generated from *webmasters* crate version *0.1.4+20140908*, where *20140908* is the exact revision of the *webmasters:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *webmasters* crate version *0.1.5+20140908*, where *20140908* is the exact revision of the *webmasters:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *webmasters* *v3* API can be found at the [official documentation site](https://developers.google.com/webmaster-tools/v3/welcome). diff --git a/gen/webmasters3/src/cmn.rs b/gen/webmasters3/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/webmasters3/src/cmn.rs +++ b/gen/webmasters3/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/webmasters3/src/lib.rs b/gen/webmasters3/src/lib.rs index b7d4ed0be59..82ca80715ca 100644 --- a/gen/webmasters3/src/lib.rs +++ b/gen/webmasters3/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *webmasters* crate version *0.1.4+20140908*, where *20140908* is the exact revision of the *webmasters:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *webmasters* crate version *0.1.5+20140908*, where *20140908* is the exact revision of the *webmasters:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *webmasters* *v3* API can be found at the //! [official documentation site](https://developers.google.com/webmaster-tools/v3/welcome). @@ -194,7 +194,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -289,43 +288,40 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct Webmasters { +pub struct Webmasters { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for Webmasters {} +impl<'a, C, A> Hub for Webmasters {} -impl<'a, C, NC, A> Webmasters - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> Webmasters + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> Webmasters { + pub fn new(client: C, authenticator: A) -> Webmasters { Webmasters { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn sitemaps(&'a self) -> SitemapMethods<'a, C, NC, A> { + pub fn sitemaps(&'a self) -> SitemapMethods<'a, C, A> { SitemapMethods { hub: &self } } - pub fn sites(&'a self) -> SiteMethods<'a, C, NC, A> { + pub fn sites(&'a self) -> SiteMethods<'a, C, A> { SiteMethods { hub: &self } } - pub fn urlcrawlerrorscounts(&'a self) -> UrlcrawlerrorscountMethods<'a, C, NC, A> { + pub fn urlcrawlerrorscounts(&'a self) -> UrlcrawlerrorscountMethods<'a, C, A> { UrlcrawlerrorscountMethods { hub: &self } } - pub fn urlcrawlerrorssamples(&'a self) -> UrlcrawlerrorssampleMethods<'a, C, NC, A> { + pub fn urlcrawlerrorssamples(&'a self) -> UrlcrawlerrorssampleMethods<'a, C, A> { UrlcrawlerrorssampleMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -605,15 +601,15 @@ impl ResponseResult for UrlCrawlErrorsSamplesListResponse {} /// let rb = hub.sitemaps(); /// # } /// ``` -pub struct SitemapMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SitemapMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Webmasters, + hub: &'a Webmasters, } -impl<'a, C, NC, A> MethodsBuilder for SitemapMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for SitemapMethods<'a, C, A> {} -impl<'a, C, NC, A> SitemapMethods<'a, C, NC, A> { +impl<'a, C, A> SitemapMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -623,7 +619,7 @@ impl<'a, C, NC, A> SitemapMethods<'a, C, NC, A> { /// /// * `siteUrl` - The site's URL, including protocol, for example 'http://www.example.com/' /// * `feedpath` - The URL of the actual sitemap (for example http://www.example.com/sitemap.xml). - pub fn delete(&self, site_url: &str, feedpath: &str) -> SitemapDeleteCall<'a, C, NC, A> { + pub fn delete(&self, site_url: &str, feedpath: &str) -> SitemapDeleteCall<'a, C, A> { SitemapDeleteCall { hub: self.hub, _site_url: site_url.to_string(), @@ -642,7 +638,7 @@ impl<'a, C, NC, A> SitemapMethods<'a, C, NC, A> { /// /// * `siteUrl` - The site's URL, including protocol, for example 'http://www.example.com/' /// * `feedpath` - The URL of the sitemap to add. - pub fn submit(&self, site_url: &str, feedpath: &str) -> SitemapSubmitCall<'a, C, NC, A> { + pub fn submit(&self, site_url: &str, feedpath: &str) -> SitemapSubmitCall<'a, C, A> { SitemapSubmitCall { hub: self.hub, _site_url: site_url.to_string(), @@ -661,7 +657,7 @@ impl<'a, C, NC, A> SitemapMethods<'a, C, NC, A> { /// /// * `siteUrl` - The site's URL, including protocol, for example 'http://www.example.com/' /// * `feedpath` - The URL of the actual sitemap (for example http://www.example.com/sitemap.xml). - pub fn get(&self, site_url: &str, feedpath: &str) -> SitemapGetCall<'a, C, NC, A> { + pub fn get(&self, site_url: &str, feedpath: &str) -> SitemapGetCall<'a, C, A> { SitemapGetCall { hub: self.hub, _site_url: site_url.to_string(), @@ -679,7 +675,7 @@ impl<'a, C, NC, A> SitemapMethods<'a, C, NC, A> { /// # Arguments /// /// * `siteUrl` - The site's URL, including protocol, for example 'http://www.example.com/' - pub fn list(&self, site_url: &str) -> SitemapListCall<'a, C, NC, A> { + pub fn list(&self, site_url: &str) -> SitemapListCall<'a, C, A> { SitemapListCall { hub: self.hub, _site_url: site_url.to_string(), @@ -721,15 +717,15 @@ impl<'a, C, NC, A> SitemapMethods<'a, C, NC, A> { /// let rb = hub.sites(); /// # } /// ``` -pub struct SiteMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SiteMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Webmasters, + hub: &'a Webmasters, } -impl<'a, C, NC, A> MethodsBuilder for SiteMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for SiteMethods<'a, C, A> {} -impl<'a, C, NC, A> SiteMethods<'a, C, NC, A> { +impl<'a, C, A> SiteMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -738,7 +734,7 @@ impl<'a, C, NC, A> SiteMethods<'a, C, NC, A> { /// # Arguments /// /// * `siteUrl` - The site's URL, including protocol, for example 'http://www.example.com/' - pub fn get(&self, site_url: &str) -> SiteGetCall<'a, C, NC, A> { + pub fn get(&self, site_url: &str) -> SiteGetCall<'a, C, A> { SiteGetCall { hub: self.hub, _site_url: site_url.to_string(), @@ -755,7 +751,7 @@ impl<'a, C, NC, A> SiteMethods<'a, C, NC, A> { /// # Arguments /// /// * `siteUrl` - The URL of the site to add. - pub fn add(&self, site_url: &str) -> SiteAddCall<'a, C, NC, A> { + pub fn add(&self, site_url: &str) -> SiteAddCall<'a, C, A> { SiteAddCall { hub: self.hub, _site_url: site_url.to_string(), @@ -768,7 +764,7 @@ impl<'a, C, NC, A> SiteMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Lists your Webmaster Tools sites. - pub fn list(&self) -> SiteListCall<'a, C, NC, A> { + pub fn list(&self) -> SiteListCall<'a, C, A> { SiteListCall { hub: self.hub, _delegate: Default::default(), @@ -784,7 +780,7 @@ impl<'a, C, NC, A> SiteMethods<'a, C, NC, A> { /// # Arguments /// /// * `siteUrl` - The site's URL, including protocol, for example 'http://www.example.com/' - pub fn delete(&self, site_url: &str) -> SiteDeleteCall<'a, C, NC, A> { + pub fn delete(&self, site_url: &str) -> SiteDeleteCall<'a, C, A> { SiteDeleteCall { hub: self.hub, _site_url: site_url.to_string(), @@ -825,15 +821,15 @@ impl<'a, C, NC, A> SiteMethods<'a, C, NC, A> { /// let rb = hub.urlcrawlerrorscounts(); /// # } /// ``` -pub struct UrlcrawlerrorscountMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlcrawlerrorscountMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Webmasters, + hub: &'a Webmasters, } -impl<'a, C, NC, A> MethodsBuilder for UrlcrawlerrorscountMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for UrlcrawlerrorscountMethods<'a, C, A> {} -impl<'a, C, NC, A> UrlcrawlerrorscountMethods<'a, C, NC, A> { +impl<'a, C, A> UrlcrawlerrorscountMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -842,7 +838,7 @@ impl<'a, C, NC, A> UrlcrawlerrorscountMethods<'a, C, NC, A> { /// # Arguments /// /// * `siteUrl` - The site's URL, including protocol, for example 'http://www.example.com/' - pub fn query(&self, site_url: &str) -> UrlcrawlerrorscountQueryCall<'a, C, NC, A> { + pub fn query(&self, site_url: &str) -> UrlcrawlerrorscountQueryCall<'a, C, A> { UrlcrawlerrorscountQueryCall { hub: self.hub, _site_url: site_url.to_string(), @@ -886,15 +882,15 @@ impl<'a, C, NC, A> UrlcrawlerrorscountMethods<'a, C, NC, A> { /// let rb = hub.urlcrawlerrorssamples(); /// # } /// ``` -pub struct UrlcrawlerrorssampleMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlcrawlerrorssampleMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Webmasters, + hub: &'a Webmasters, } -impl<'a, C, NC, A> MethodsBuilder for UrlcrawlerrorssampleMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for UrlcrawlerrorssampleMethods<'a, C, A> {} -impl<'a, C, NC, A> UrlcrawlerrorssampleMethods<'a, C, NC, A> { +impl<'a, C, A> UrlcrawlerrorssampleMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -906,7 +902,7 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleMethods<'a, C, NC, A> { /// * `url` - The relative path (without the site) of the sample URL; must be one of the URLs returned by list /// * `category` - The crawl error category, for example 'authPermissions' /// * `platform` - The user agent type (platform) that made the request, for example 'web' - pub fn get(&self, site_url: &str, url: &str, category: &str, platform: &str) -> UrlcrawlerrorssampleGetCall<'a, C, NC, A> { + pub fn get(&self, site_url: &str, url: &str, category: &str, platform: &str) -> UrlcrawlerrorssampleGetCall<'a, C, A> { UrlcrawlerrorssampleGetCall { hub: self.hub, _site_url: site_url.to_string(), @@ -928,7 +924,7 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleMethods<'a, C, NC, A> { /// * `siteUrl` - The site's URL, including protocol, for example 'http://www.example.com/' /// * `category` - The crawl error category, for example 'authPermissions' /// * `platform` - The user agent type (platform) that made the request, for example 'web' - pub fn list(&self, site_url: &str, category: &str, platform: &str) -> UrlcrawlerrorssampleListCall<'a, C, NC, A> { + pub fn list(&self, site_url: &str, category: &str, platform: &str) -> UrlcrawlerrorssampleListCall<'a, C, A> { UrlcrawlerrorssampleListCall { hub: self.hub, _site_url: site_url.to_string(), @@ -950,7 +946,7 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleMethods<'a, C, NC, A> { /// * `url` - The relative path (without the site) of the sample URL; must be one of the URLs returned by list /// * `category` - The crawl error category, for example 'authPermissions' /// * `platform` - The user agent type (platform) that made the request, for example 'web' - pub fn mark_as_fixed(&self, site_url: &str, url: &str, category: &str, platform: &str) -> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, NC, A> { + pub fn mark_as_fixed(&self, site_url: &str, url: &str, category: &str, platform: &str) -> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, A> { UrlcrawlerrorssampleMarkAsFixedCall { hub: self.hub, _site_url: site_url.to_string(), @@ -1002,10 +998,10 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct SitemapDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SitemapDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Webmasters, + hub: &'a Webmasters, _site_url: String, _feedpath: String, _delegate: Option<&'a mut Delegate>, @@ -1013,9 +1009,9 @@ pub struct SitemapDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SitemapDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SitemapDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> SitemapDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SitemapDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1137,7 +1133,7 @@ impl<'a, C, NC, A> SitemapDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The site's URL, including protocol, for example 'http://www.example.com/' - pub fn site_url(mut self, new_value: &str) -> SitemapDeleteCall<'a, C, NC, A> { + pub fn site_url(mut self, new_value: &str) -> SitemapDeleteCall<'a, C, A> { self._site_url = new_value.to_string(); self } @@ -1147,7 +1143,7 @@ impl<'a, C, NC, A> SitemapDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The URL of the actual sitemap (for example http://www.example.com/sitemap.xml). - pub fn feedpath(mut self, new_value: &str) -> SitemapDeleteCall<'a, C, NC, A> { + pub fn feedpath(mut self, new_value: &str) -> SitemapDeleteCall<'a, C, A> { self._feedpath = new_value.to_string(); self } @@ -1158,7 +1154,7 @@ impl<'a, C, NC, A> SitemapDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SitemapDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SitemapDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1179,7 +1175,7 @@ impl<'a, C, NC, A> SitemapDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SitemapDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SitemapDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1196,7 +1192,7 @@ impl<'a, C, NC, A> SitemapDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SitemapDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SitemapDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1234,10 +1230,10 @@ impl<'a, C, NC, A> SitemapDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct SitemapSubmitCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SitemapSubmitCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Webmasters, + hub: &'a Webmasters, _site_url: String, _feedpath: String, _delegate: Option<&'a mut Delegate>, @@ -1245,9 +1241,9 @@ pub struct SitemapSubmitCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SitemapSubmitCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SitemapSubmitCall<'a, C, A> {} -impl<'a, C, NC, A> SitemapSubmitCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SitemapSubmitCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1369,7 +1365,7 @@ impl<'a, C, NC, A> SitemapSubmitCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The site's URL, including protocol, for example 'http://www.example.com/' - pub fn site_url(mut self, new_value: &str) -> SitemapSubmitCall<'a, C, NC, A> { + pub fn site_url(mut self, new_value: &str) -> SitemapSubmitCall<'a, C, A> { self._site_url = new_value.to_string(); self } @@ -1379,7 +1375,7 @@ impl<'a, C, NC, A> SitemapSubmitCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The URL of the sitemap to add. - pub fn feedpath(mut self, new_value: &str) -> SitemapSubmitCall<'a, C, NC, A> { + pub fn feedpath(mut self, new_value: &str) -> SitemapSubmitCall<'a, C, A> { self._feedpath = new_value.to_string(); self } @@ -1390,7 +1386,7 @@ impl<'a, C, NC, A> SitemapSubmitCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SitemapSubmitCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SitemapSubmitCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1411,7 +1407,7 @@ impl<'a, C, NC, A> SitemapSubmitCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SitemapSubmitCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SitemapSubmitCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1428,7 +1424,7 @@ impl<'a, C, NC, A> SitemapSubmitCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SitemapSubmitCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SitemapSubmitCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1466,10 +1462,10 @@ impl<'a, C, NC, A> SitemapSubmitCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct SitemapGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SitemapGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Webmasters, + hub: &'a Webmasters, _site_url: String, _feedpath: String, _delegate: Option<&'a mut Delegate>, @@ -1477,9 +1473,9 @@ pub struct SitemapGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SitemapGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SitemapGetCall<'a, C, A> {} -impl<'a, C, NC, A> SitemapGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SitemapGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1612,7 +1608,7 @@ impl<'a, C, NC, A> SitemapGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The site's URL, including protocol, for example 'http://www.example.com/' - pub fn site_url(mut self, new_value: &str) -> SitemapGetCall<'a, C, NC, A> { + pub fn site_url(mut self, new_value: &str) -> SitemapGetCall<'a, C, A> { self._site_url = new_value.to_string(); self } @@ -1622,7 +1618,7 @@ impl<'a, C, NC, A> SitemapGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The URL of the actual sitemap (for example http://www.example.com/sitemap.xml). - pub fn feedpath(mut self, new_value: &str) -> SitemapGetCall<'a, C, NC, A> { + pub fn feedpath(mut self, new_value: &str) -> SitemapGetCall<'a, C, A> { self._feedpath = new_value.to_string(); self } @@ -1633,7 +1629,7 @@ impl<'a, C, NC, A> SitemapGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SitemapGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SitemapGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1654,7 +1650,7 @@ impl<'a, C, NC, A> SitemapGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SitemapGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SitemapGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1671,7 +1667,7 @@ impl<'a, C, NC, A> SitemapGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SitemapGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SitemapGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1710,10 +1706,10 @@ impl<'a, C, NC, A> SitemapGetCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct SitemapListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SitemapListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Webmasters, + hub: &'a Webmasters, _site_url: String, _sitemap_index: Option, _delegate: Option<&'a mut Delegate>, @@ -1721,9 +1717,9 @@ pub struct SitemapListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SitemapListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SitemapListCall<'a, C, A> {} -impl<'a, C, NC, A> SitemapListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SitemapListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1858,7 +1854,7 @@ impl<'a, C, NC, A> SitemapListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The site's URL, including protocol, for example 'http://www.example.com/' - pub fn site_url(mut self, new_value: &str) -> SitemapListCall<'a, C, NC, A> { + pub fn site_url(mut self, new_value: &str) -> SitemapListCall<'a, C, A> { self._site_url = new_value.to_string(); self } @@ -1866,7 +1862,7 @@ impl<'a, C, NC, A> SitemapListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// A URL of a site's sitemap index. - pub fn sitemap_index(mut self, new_value: &str) -> SitemapListCall<'a, C, NC, A> { + pub fn sitemap_index(mut self, new_value: &str) -> SitemapListCall<'a, C, A> { self._sitemap_index = Some(new_value.to_string()); self } @@ -1877,7 +1873,7 @@ impl<'a, C, NC, A> SitemapListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SitemapListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SitemapListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1898,7 +1894,7 @@ impl<'a, C, NC, A> SitemapListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SitemapListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SitemapListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1915,7 +1911,7 @@ impl<'a, C, NC, A> SitemapListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SitemapListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SitemapListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1953,19 +1949,19 @@ impl<'a, C, NC, A> SitemapListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct SiteGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SiteGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Webmasters, + hub: &'a Webmasters, _site_url: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SiteGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SiteGetCall<'a, C, A> {} -impl<'a, C, NC, A> SiteGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SiteGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2097,7 +2093,7 @@ impl<'a, C, NC, A> SiteGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// The site's URL, including protocol, for example 'http://www.example.com/' - pub fn site_url(mut self, new_value: &str) -> SiteGetCall<'a, C, NC, A> { + pub fn site_url(mut self, new_value: &str) -> SiteGetCall<'a, C, A> { self._site_url = new_value.to_string(); self } @@ -2108,7 +2104,7 @@ impl<'a, C, NC, A> SiteGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SiteGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SiteGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2129,7 +2125,7 @@ impl<'a, C, NC, A> SiteGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SiteGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SiteGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2146,7 +2142,7 @@ impl<'a, C, NC, A> SiteGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SiteGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SiteGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2184,19 +2180,19 @@ impl<'a, C, NC, A> SiteGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct SiteAddCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SiteAddCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Webmasters, + hub: &'a Webmasters, _site_url: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SiteAddCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SiteAddCall<'a, C, A> {} -impl<'a, C, NC, A> SiteAddCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SiteAddCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2317,7 +2313,7 @@ impl<'a, C, NC, A> SiteAddCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// we provide this method for API completeness. /// /// The URL of the site to add. - pub fn site_url(mut self, new_value: &str) -> SiteAddCall<'a, C, NC, A> { + pub fn site_url(mut self, new_value: &str) -> SiteAddCall<'a, C, A> { self._site_url = new_value.to_string(); self } @@ -2328,7 +2324,7 @@ impl<'a, C, NC, A> SiteAddCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SiteAddCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SiteAddCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2349,7 +2345,7 @@ impl<'a, C, NC, A> SiteAddCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SiteAddCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SiteAddCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2366,7 +2362,7 @@ impl<'a, C, NC, A> SiteAddCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SiteAddCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SiteAddCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2404,18 +2400,18 @@ impl<'a, C, NC, A> SiteAddCall<'a, C, NC, A> where NC: hyper::net::NetworkConnec /// .doit(); /// # } /// ``` -pub struct SiteListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SiteListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Webmasters, + hub: &'a Webmasters, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SiteListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SiteListCall<'a, C, A> {} -impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SiteListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2523,7 +2519,7 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SiteListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SiteListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2544,7 +2540,7 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SiteListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SiteListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2561,7 +2557,7 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SiteListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SiteListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2599,19 +2595,19 @@ impl<'a, C, NC, A> SiteListCall<'a, C, NC, A> where NC: hyper::net::NetworkConne /// .doit(); /// # } /// ``` -pub struct SiteDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SiteDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Webmasters, + hub: &'a Webmasters, _site_url: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SiteDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SiteDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> SiteDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SiteDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2732,7 +2728,7 @@ impl<'a, C, NC, A> SiteDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// we provide this method for API completeness. /// /// The site's URL, including protocol, for example 'http://www.example.com/' - pub fn site_url(mut self, new_value: &str) -> SiteDeleteCall<'a, C, NC, A> { + pub fn site_url(mut self, new_value: &str) -> SiteDeleteCall<'a, C, A> { self._site_url = new_value.to_string(); self } @@ -2743,7 +2739,7 @@ impl<'a, C, NC, A> SiteDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SiteDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SiteDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2764,7 +2760,7 @@ impl<'a, C, NC, A> SiteDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SiteDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SiteDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2781,7 +2777,7 @@ impl<'a, C, NC, A> SiteDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SiteDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SiteDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2822,10 +2818,10 @@ impl<'a, C, NC, A> SiteDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct UrlcrawlerrorscountQueryCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlcrawlerrorscountQueryCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Webmasters, + hub: &'a Webmasters, _site_url: String, _platform: Option, _latest_counts_only: Option, @@ -2835,9 +2831,9 @@ pub struct UrlcrawlerrorscountQueryCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UrlcrawlerrorscountQueryCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UrlcrawlerrorscountQueryCall<'a, C, A> {} -impl<'a, C, NC, A> UrlcrawlerrorscountQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UrlcrawlerrorscountQueryCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2978,7 +2974,7 @@ impl<'a, C, NC, A> UrlcrawlerrorscountQueryCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The site's URL, including protocol, for example 'http://www.example.com/' - pub fn site_url(mut self, new_value: &str) -> UrlcrawlerrorscountQueryCall<'a, C, NC, A> { + pub fn site_url(mut self, new_value: &str) -> UrlcrawlerrorscountQueryCall<'a, C, A> { self._site_url = new_value.to_string(); self } @@ -2986,7 +2982,7 @@ impl<'a, C, NC, A> UrlcrawlerrorscountQueryCall<'a, C, NC, A> where NC: hyper::n /// /// /// The user agent type (platform) that made the request, for example 'web'. If not specified, we return results for all platforms. - pub fn platform(mut self, new_value: &str) -> UrlcrawlerrorscountQueryCall<'a, C, NC, A> { + pub fn platform(mut self, new_value: &str) -> UrlcrawlerrorscountQueryCall<'a, C, A> { self._platform = Some(new_value.to_string()); self } @@ -2994,7 +2990,7 @@ impl<'a, C, NC, A> UrlcrawlerrorscountQueryCall<'a, C, NC, A> where NC: hyper::n /// /// /// If true, returns only the latest crawl error counts. - pub fn latest_counts_only(mut self, new_value: bool) -> UrlcrawlerrorscountQueryCall<'a, C, NC, A> { + pub fn latest_counts_only(mut self, new_value: bool) -> UrlcrawlerrorscountQueryCall<'a, C, A> { self._latest_counts_only = Some(new_value); self } @@ -3002,7 +2998,7 @@ impl<'a, C, NC, A> UrlcrawlerrorscountQueryCall<'a, C, NC, A> where NC: hyper::n /// /// /// The crawl error category, for example 'serverError'. If not specified, we return results for all categories. - pub fn category(mut self, new_value: &str) -> UrlcrawlerrorscountQueryCall<'a, C, NC, A> { + pub fn category(mut self, new_value: &str) -> UrlcrawlerrorscountQueryCall<'a, C, A> { self._category = Some(new_value.to_string()); self } @@ -3013,7 +3009,7 @@ impl<'a, C, NC, A> UrlcrawlerrorscountQueryCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlcrawlerrorscountQueryCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlcrawlerrorscountQueryCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3034,7 +3030,7 @@ impl<'a, C, NC, A> UrlcrawlerrorscountQueryCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UrlcrawlerrorscountQueryCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UrlcrawlerrorscountQueryCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3051,7 +3047,7 @@ impl<'a, C, NC, A> UrlcrawlerrorscountQueryCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UrlcrawlerrorscountQueryCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UrlcrawlerrorscountQueryCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3089,10 +3085,10 @@ impl<'a, C, NC, A> UrlcrawlerrorscountQueryCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct UrlcrawlerrorssampleGetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlcrawlerrorssampleGetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Webmasters, + hub: &'a Webmasters, _site_url: String, _url: String, _category: String, @@ -3102,9 +3098,9 @@ pub struct UrlcrawlerrorssampleGetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UrlcrawlerrorssampleGetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UrlcrawlerrorssampleGetCall<'a, C, A> {} -impl<'a, C, NC, A> UrlcrawlerrorssampleGetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UrlcrawlerrorssampleGetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3239,7 +3235,7 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The site's URL, including protocol, for example 'http://www.example.com/' - pub fn site_url(mut self, new_value: &str) -> UrlcrawlerrorssampleGetCall<'a, C, NC, A> { + pub fn site_url(mut self, new_value: &str) -> UrlcrawlerrorssampleGetCall<'a, C, A> { self._site_url = new_value.to_string(); self } @@ -3249,7 +3245,7 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The relative path (without the site) of the sample URL; must be one of the URLs returned by list - pub fn url(mut self, new_value: &str) -> UrlcrawlerrorssampleGetCall<'a, C, NC, A> { + pub fn url(mut self, new_value: &str) -> UrlcrawlerrorssampleGetCall<'a, C, A> { self._url = new_value.to_string(); self } @@ -3259,7 +3255,7 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The crawl error category, for example 'authPermissions' - pub fn category(mut self, new_value: &str) -> UrlcrawlerrorssampleGetCall<'a, C, NC, A> { + pub fn category(mut self, new_value: &str) -> UrlcrawlerrorssampleGetCall<'a, C, A> { self._category = new_value.to_string(); self } @@ -3269,7 +3265,7 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleGetCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The user agent type (platform) that made the request, for example 'web' - pub fn platform(mut self, new_value: &str) -> UrlcrawlerrorssampleGetCall<'a, C, NC, A> { + pub fn platform(mut self, new_value: &str) -> UrlcrawlerrorssampleGetCall<'a, C, A> { self._platform = new_value.to_string(); self } @@ -3280,7 +3276,7 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleGetCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlcrawlerrorssampleGetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlcrawlerrorssampleGetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3301,7 +3297,7 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleGetCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UrlcrawlerrorssampleGetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UrlcrawlerrorssampleGetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3318,7 +3314,7 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleGetCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UrlcrawlerrorssampleGetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UrlcrawlerrorssampleGetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3356,10 +3352,10 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleGetCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct UrlcrawlerrorssampleListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlcrawlerrorssampleListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Webmasters, + hub: &'a Webmasters, _site_url: String, _category: String, _platform: String, @@ -3368,9 +3364,9 @@ pub struct UrlcrawlerrorssampleListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UrlcrawlerrorssampleListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UrlcrawlerrorssampleListCall<'a, C, A> {} -impl<'a, C, NC, A> UrlcrawlerrorssampleListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UrlcrawlerrorssampleListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3504,7 +3500,7 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleListCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The site's URL, including protocol, for example 'http://www.example.com/' - pub fn site_url(mut self, new_value: &str) -> UrlcrawlerrorssampleListCall<'a, C, NC, A> { + pub fn site_url(mut self, new_value: &str) -> UrlcrawlerrorssampleListCall<'a, C, A> { self._site_url = new_value.to_string(); self } @@ -3514,7 +3510,7 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleListCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The crawl error category, for example 'authPermissions' - pub fn category(mut self, new_value: &str) -> UrlcrawlerrorssampleListCall<'a, C, NC, A> { + pub fn category(mut self, new_value: &str) -> UrlcrawlerrorssampleListCall<'a, C, A> { self._category = new_value.to_string(); self } @@ -3524,7 +3520,7 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleListCall<'a, C, NC, A> where NC: hyper::n /// we provide this method for API completeness. /// /// The user agent type (platform) that made the request, for example 'web' - pub fn platform(mut self, new_value: &str) -> UrlcrawlerrorssampleListCall<'a, C, NC, A> { + pub fn platform(mut self, new_value: &str) -> UrlcrawlerrorssampleListCall<'a, C, A> { self._platform = new_value.to_string(); self } @@ -3535,7 +3531,7 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleListCall<'a, C, NC, A> where NC: hyper::n /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlcrawlerrorssampleListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlcrawlerrorssampleListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3556,7 +3552,7 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleListCall<'a, C, NC, A> where NC: hyper::n /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UrlcrawlerrorssampleListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UrlcrawlerrorssampleListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3573,7 +3569,7 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleListCall<'a, C, NC, A> where NC: hyper::n /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UrlcrawlerrorssampleListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UrlcrawlerrorssampleListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3611,10 +3607,10 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleListCall<'a, C, NC, A> where NC: hyper::n /// .doit(); /// # } /// ``` -pub struct UrlcrawlerrorssampleMarkAsFixedCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct UrlcrawlerrorssampleMarkAsFixedCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a Webmasters, + hub: &'a Webmasters, _site_url: String, _url: String, _category: String, @@ -3624,9 +3620,9 @@ pub struct UrlcrawlerrorssampleMarkAsFixedCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for UrlcrawlerrorssampleMarkAsFixedCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for UrlcrawlerrorssampleMarkAsFixedCall<'a, C, A> {} -impl<'a, C, NC, A> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3750,7 +3746,7 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// The site's URL, including protocol, for example 'http://www.example.com/' - pub fn site_url(mut self, new_value: &str) -> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, NC, A> { + pub fn site_url(mut self, new_value: &str) -> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, A> { self._site_url = new_value.to_string(); self } @@ -3760,7 +3756,7 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// The relative path (without the site) of the sample URL; must be one of the URLs returned by list - pub fn url(mut self, new_value: &str) -> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, NC, A> { + pub fn url(mut self, new_value: &str) -> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, A> { self._url = new_value.to_string(); self } @@ -3770,7 +3766,7 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// The crawl error category, for example 'authPermissions' - pub fn category(mut self, new_value: &str) -> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, NC, A> { + pub fn category(mut self, new_value: &str) -> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, A> { self._category = new_value.to_string(); self } @@ -3780,7 +3776,7 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, NC, A> where NC: h /// we provide this method for API completeness. /// /// The user agent type (platform) that made the request, for example 'web' - pub fn platform(mut self, new_value: &str) -> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, NC, A> { + pub fn platform(mut self, new_value: &str) -> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, A> { self._platform = new_value.to_string(); self } @@ -3791,7 +3787,7 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, NC, A> where NC: h /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3812,7 +3808,7 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, NC, A> where NC: h /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3829,7 +3825,7 @@ impl<'a, C, NC, A> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, NC, A> where NC: h /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> UrlcrawlerrorssampleMarkAsFixedCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/youtube3/README.md b/gen/youtube3/README.md index 11720b37ce1..30cb9554710 100644 --- a/gen/youtube3/README.md +++ b/gen/youtube3/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-youtube3` library allows access to all features of the *Google YouTube* service. -This documentation was generated from *YouTube* crate version *0.1.4+20150327*, where *20150327* is the exact revision of the *youtube:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *YouTube* crate version *0.1.5+20150327*, where *20150327* is the exact revision of the *youtube:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *YouTube* *v3* API can be found at the [official documentation site](https://developers.google.com/youtube/v3). diff --git a/gen/youtube3/cargo.toml b/gen/youtube3/cargo.toml index 9a9645a7fba..c4523c9389f 100644 --- a/gen/youtube3/cargo.toml +++ b/gen/youtube3/cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-youtube3" -version = "0.1.4+20150327" +version = "0.1.5+20150327" authors = ["Sebastian Thiel "] description = "A complete library to interact with YouTube (protocol v3)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/youtube3" homepage = "https://developers.google.com/youtube/v3" -documentation = "http://byron.github.io/google-apis-rs/google-youtube3" +documentation = "http://byron.github.io/google-apis-rs/google_youtube3" license = "MIT" keywords = ["youtube", "google", "protocol", "web", "api"] diff --git a/gen/youtube3/src/cmn.rs b/gen/youtube3/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/youtube3/src/cmn.rs +++ b/gen/youtube3/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/youtube3/src/lib.rs b/gen/youtube3/src/lib.rs index 76e847f836a..aadbd611ffd 100644 --- a/gen/youtube3/src/lib.rs +++ b/gen/youtube3/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *YouTube* crate version *0.1.4+20150327*, where *20150327* is the exact revision of the *youtube:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *YouTube* crate version *0.1.5+20150327*, where *20150327* is the exact revision of the *youtube:v3* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *YouTube* *v3* API can be found at the //! [official documentation site](https://developers.google.com/youtube/v3). @@ -252,7 +252,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -370,85 +369,82 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct YouTube { +pub struct YouTube { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for YouTube {} +impl<'a, C, A> Hub for YouTube {} -impl<'a, C, NC, A> YouTube - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> YouTube + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> YouTube { + pub fn new(client: C, authenticator: A) -> YouTube { YouTube { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn activities(&'a self) -> ActivityMethods<'a, C, NC, A> { + pub fn activities(&'a self) -> ActivityMethods<'a, C, A> { ActivityMethods { hub: &self } } - pub fn captions(&'a self) -> CaptionMethods<'a, C, NC, A> { + pub fn captions(&'a self) -> CaptionMethods<'a, C, A> { CaptionMethods { hub: &self } } - pub fn channel_banners(&'a self) -> ChannelBannerMethods<'a, C, NC, A> { + pub fn channel_banners(&'a self) -> ChannelBannerMethods<'a, C, A> { ChannelBannerMethods { hub: &self } } - pub fn channel_sections(&'a self) -> ChannelSectionMethods<'a, C, NC, A> { + pub fn channel_sections(&'a self) -> ChannelSectionMethods<'a, C, A> { ChannelSectionMethods { hub: &self } } - pub fn channels(&'a self) -> ChannelMethods<'a, C, NC, A> { + pub fn channels(&'a self) -> ChannelMethods<'a, C, A> { ChannelMethods { hub: &self } } - pub fn guide_categories(&'a self) -> GuideCategoryMethods<'a, C, NC, A> { + pub fn guide_categories(&'a self) -> GuideCategoryMethods<'a, C, A> { GuideCategoryMethods { hub: &self } } - pub fn i18n_languages(&'a self) -> I18nLanguageMethods<'a, C, NC, A> { + pub fn i18n_languages(&'a self) -> I18nLanguageMethods<'a, C, A> { I18nLanguageMethods { hub: &self } } - pub fn i18n_regions(&'a self) -> I18nRegionMethods<'a, C, NC, A> { + pub fn i18n_regions(&'a self) -> I18nRegionMethods<'a, C, A> { I18nRegionMethods { hub: &self } } - pub fn live_broadcasts(&'a self) -> LiveBroadcastMethods<'a, C, NC, A> { + pub fn live_broadcasts(&'a self) -> LiveBroadcastMethods<'a, C, A> { LiveBroadcastMethods { hub: &self } } - pub fn live_streams(&'a self) -> LiveStreamMethods<'a, C, NC, A> { + pub fn live_streams(&'a self) -> LiveStreamMethods<'a, C, A> { LiveStreamMethods { hub: &self } } - pub fn playlist_items(&'a self) -> PlaylistItemMethods<'a, C, NC, A> { + pub fn playlist_items(&'a self) -> PlaylistItemMethods<'a, C, A> { PlaylistItemMethods { hub: &self } } - pub fn playlists(&'a self) -> PlaylistMethods<'a, C, NC, A> { + pub fn playlists(&'a self) -> PlaylistMethods<'a, C, A> { PlaylistMethods { hub: &self } } - pub fn search(&'a self) -> SearchMethods<'a, C, NC, A> { + pub fn search(&'a self) -> SearchMethods<'a, C, A> { SearchMethods { hub: &self } } - pub fn subscriptions(&'a self) -> SubscriptionMethods<'a, C, NC, A> { + pub fn subscriptions(&'a self) -> SubscriptionMethods<'a, C, A> { SubscriptionMethods { hub: &self } } - pub fn thumbnails(&'a self) -> ThumbnailMethods<'a, C, NC, A> { + pub fn thumbnails(&'a self) -> ThumbnailMethods<'a, C, A> { ThumbnailMethods { hub: &self } } - pub fn video_categories(&'a self) -> VideoCategoryMethods<'a, C, NC, A> { + pub fn video_categories(&'a self) -> VideoCategoryMethods<'a, C, A> { VideoCategoryMethods { hub: &self } } - pub fn videos(&'a self) -> VideoMethods<'a, C, NC, A> { + pub fn videos(&'a self) -> VideoMethods<'a, C, A> { VideoMethods { hub: &self } } - pub fn watermarks(&'a self) -> WatermarkMethods<'a, C, NC, A> { + pub fn watermarks(&'a self) -> WatermarkMethods<'a, C, A> { WatermarkMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -4190,15 +4186,15 @@ impl Part for SearchResultSnippet {} /// let rb = hub.i18n_languages(); /// # } /// ``` -pub struct I18nLanguageMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct I18nLanguageMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, } -impl<'a, C, NC, A> MethodsBuilder for I18nLanguageMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for I18nLanguageMethods<'a, C, A> {} -impl<'a, C, NC, A> I18nLanguageMethods<'a, C, NC, A> { +impl<'a, C, A> I18nLanguageMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -4207,7 +4203,7 @@ impl<'a, C, NC, A> I18nLanguageMethods<'a, C, NC, A> { /// # Arguments /// /// * `part` - The part parameter specifies a comma-separated list of one or more i18nLanguage resource properties that the API response will include. The part names that you can include in the parameter value are id and snippet. - pub fn list(&self, part: &str) -> I18nLanguageListCall<'a, C, NC, A> { + pub fn list(&self, part: &str) -> I18nLanguageListCall<'a, C, A> { I18nLanguageListCall { hub: self.hub, _part: part.to_string(), @@ -4249,15 +4245,15 @@ impl<'a, C, NC, A> I18nLanguageMethods<'a, C, NC, A> { /// let rb = hub.channel_banners(); /// # } /// ``` -pub struct ChannelBannerMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChannelBannerMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, } -impl<'a, C, NC, A> MethodsBuilder for ChannelBannerMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ChannelBannerMethods<'a, C, A> {} -impl<'a, C, NC, A> ChannelBannerMethods<'a, C, NC, A> { +impl<'a, C, A> ChannelBannerMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -4270,7 +4266,7 @@ impl<'a, C, NC, A> ChannelBannerMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &ChannelBannerResource) -> ChannelBannerInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &ChannelBannerResource) -> ChannelBannerInsertCall<'a, C, A> { ChannelBannerInsertCall { hub: self.hub, _request: request.clone(), @@ -4312,15 +4308,15 @@ impl<'a, C, NC, A> ChannelBannerMethods<'a, C, NC, A> { /// let rb = hub.channel_sections(); /// # } /// ``` -pub struct ChannelSectionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChannelSectionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, } -impl<'a, C, NC, A> MethodsBuilder for ChannelSectionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ChannelSectionMethods<'a, C, A> {} -impl<'a, C, NC, A> ChannelSectionMethods<'a, C, NC, A> { +impl<'a, C, A> ChannelSectionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -4330,7 +4326,7 @@ impl<'a, C, NC, A> ChannelSectionMethods<'a, C, NC, A> { /// /// * `part` - The part parameter specifies a comma-separated list of one or more channelSection resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, and contentDetails. /// If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a channelSection resource, the snippet property contains other properties, such as a display title for the channelSection. If you set part=snippet, the API response will also contain all of those nested properties. - pub fn list(&self, part: &str) -> ChannelSectionListCall<'a, C, NC, A> { + pub fn list(&self, part: &str) -> ChannelSectionListCall<'a, C, A> { ChannelSectionListCall { hub: self.hub, _part: part.to_string(), @@ -4352,7 +4348,7 @@ impl<'a, C, NC, A> ChannelSectionMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &ChannelSection) -> ChannelSectionInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &ChannelSection) -> ChannelSectionInsertCall<'a, C, A> { ChannelSectionInsertCall { hub: self.hub, _request: request.clone(), @@ -4372,7 +4368,7 @@ impl<'a, C, NC, A> ChannelSectionMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The id parameter specifies the YouTube channelSection ID for the resource that is being deleted. In a channelSection resource, the id property specifies the YouTube channelSection ID. - pub fn delete(&self, id: &str) -> ChannelSectionDeleteCall<'a, C, NC, A> { + pub fn delete(&self, id: &str) -> ChannelSectionDeleteCall<'a, C, A> { ChannelSectionDeleteCall { hub: self.hub, _id: id.to_string(), @@ -4390,7 +4386,7 @@ impl<'a, C, NC, A> ChannelSectionMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn update(&self, request: &ChannelSection) -> ChannelSectionUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &ChannelSection) -> ChannelSectionUpdateCall<'a, C, A> { ChannelSectionUpdateCall { hub: self.hub, _request: request.clone(), @@ -4433,15 +4429,15 @@ impl<'a, C, NC, A> ChannelSectionMethods<'a, C, NC, A> { /// let rb = hub.guide_categories(); /// # } /// ``` -pub struct GuideCategoryMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GuideCategoryMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, } -impl<'a, C, NC, A> MethodsBuilder for GuideCategoryMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for GuideCategoryMethods<'a, C, A> {} -impl<'a, C, NC, A> GuideCategoryMethods<'a, C, NC, A> { +impl<'a, C, A> GuideCategoryMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -4451,7 +4447,7 @@ impl<'a, C, NC, A> GuideCategoryMethods<'a, C, NC, A> { /// /// * `part` - The part parameter specifies a comma-separated list of one or more guideCategory resource properties that the API response will include. The part names that you can include in the parameter value are id and snippet. /// If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a guideCategory resource, the snippet property contains other properties, such as the category's title. If you set part=snippet, the API response will also contain all of those nested properties. - pub fn list(&self, part: &str) -> GuideCategoryListCall<'a, C, NC, A> { + pub fn list(&self, part: &str) -> GuideCategoryListCall<'a, C, A> { GuideCategoryListCall { hub: self.hub, _part: part.to_string(), @@ -4495,15 +4491,15 @@ impl<'a, C, NC, A> GuideCategoryMethods<'a, C, NC, A> { /// let rb = hub.playlists(); /// # } /// ``` -pub struct PlaylistMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlaylistMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, } -impl<'a, C, NC, A> MethodsBuilder for PlaylistMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PlaylistMethods<'a, C, A> {} -impl<'a, C, NC, A> PlaylistMethods<'a, C, NC, A> { +impl<'a, C, A> PlaylistMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -4512,7 +4508,7 @@ impl<'a, C, NC, A> PlaylistMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &Playlist) -> PlaylistInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Playlist) -> PlaylistInsertCall<'a, C, A> { PlaylistInsertCall { hub: self.hub, _request: request.clone(), @@ -4533,7 +4529,7 @@ impl<'a, C, NC, A> PlaylistMethods<'a, C, NC, A> { /// /// * `part` - The part parameter specifies a comma-separated list of one or more playlist resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, status, and contentDetails. /// If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a playlist resource, the snippet property contains properties like author, title, description, tags, and timeCreated. As such, if you set part=snippet, the API response will contain all of those properties. - pub fn list(&self, part: &str) -> PlaylistListCall<'a, C, NC, A> { + pub fn list(&self, part: &str) -> PlaylistListCall<'a, C, A> { PlaylistListCall { hub: self.hub, _part: part.to_string(), @@ -4558,7 +4554,7 @@ impl<'a, C, NC, A> PlaylistMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The id parameter specifies the YouTube playlist ID for the playlist that is being deleted. In a playlist resource, the id property specifies the playlist's ID. - pub fn delete(&self, id: &str) -> PlaylistDeleteCall<'a, C, NC, A> { + pub fn delete(&self, id: &str) -> PlaylistDeleteCall<'a, C, A> { PlaylistDeleteCall { hub: self.hub, _id: id.to_string(), @@ -4576,7 +4572,7 @@ impl<'a, C, NC, A> PlaylistMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn update(&self, request: &Playlist) -> PlaylistUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Playlist) -> PlaylistUpdateCall<'a, C, A> { PlaylistUpdateCall { hub: self.hub, _request: request.clone(), @@ -4619,15 +4615,15 @@ impl<'a, C, NC, A> PlaylistMethods<'a, C, NC, A> { /// let rb = hub.thumbnails(); /// # } /// ``` -pub struct ThumbnailMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ThumbnailMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, } -impl<'a, C, NC, A> MethodsBuilder for ThumbnailMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ThumbnailMethods<'a, C, A> {} -impl<'a, C, NC, A> ThumbnailMethods<'a, C, NC, A> { +impl<'a, C, A> ThumbnailMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -4636,7 +4632,7 @@ impl<'a, C, NC, A> ThumbnailMethods<'a, C, NC, A> { /// # Arguments /// /// * `videoId` - The videoId parameter specifies a YouTube video ID for which the custom video thumbnail is being provided. - pub fn set(&self, video_id: &str) -> ThumbnailSetCall<'a, C, NC, A> { + pub fn set(&self, video_id: &str) -> ThumbnailSetCall<'a, C, A> { ThumbnailSetCall { hub: self.hub, _video_id: video_id.to_string(), @@ -4678,15 +4674,15 @@ impl<'a, C, NC, A> ThumbnailMethods<'a, C, NC, A> { /// let rb = hub.videos(); /// # } /// ``` -pub struct VideoMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VideoMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, } -impl<'a, C, NC, A> MethodsBuilder for VideoMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for VideoMethods<'a, C, A> {} -impl<'a, C, NC, A> VideoMethods<'a, C, NC, A> { +impl<'a, C, A> VideoMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -4696,7 +4692,7 @@ impl<'a, C, NC, A> VideoMethods<'a, C, NC, A> { /// /// * `part` - The part parameter specifies a comma-separated list of one or more video resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, contentDetails, fileDetails, liveStreamingDetails, localizations, player, processingDetails, recordingDetails, statistics, status, suggestions, and topicDetails. /// If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a video resource, the snippet property contains the channelId, title, description, tags, and categoryId properties. As such, if you set part=snippet, the API response will contain all of those properties. - pub fn list(&self, part: &str) -> VideoListCall<'a, C, NC, A> { + pub fn list(&self, part: &str) -> VideoListCall<'a, C, A> { VideoListCall { hub: self.hub, _part: part.to_string(), @@ -4724,7 +4720,7 @@ impl<'a, C, NC, A> VideoMethods<'a, C, NC, A> { /// /// * `id` - The id parameter specifies the YouTube video ID of the video that is being rated or having its rating removed. /// * `rating` - Specifies the rating to record. - pub fn rate(&self, id: &str, rating: &str) -> VideoRateCall<'a, C, NC, A> { + pub fn rate(&self, id: &str, rating: &str) -> VideoRateCall<'a, C, A> { VideoRateCall { hub: self.hub, _id: id.to_string(), @@ -4743,7 +4739,7 @@ impl<'a, C, NC, A> VideoMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The id parameter specifies a comma-separated list of the YouTube video ID(s) for the resource(s) for which you are retrieving rating data. In a video resource, the id property specifies the video's ID. - pub fn get_rating(&self, id: &str) -> VideoGetRatingCall<'a, C, NC, A> { + pub fn get_rating(&self, id: &str) -> VideoGetRatingCall<'a, C, A> { VideoGetRatingCall { hub: self.hub, _id: id.to_string(), @@ -4761,7 +4757,7 @@ impl<'a, C, NC, A> VideoMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The id parameter specifies the YouTube video ID for the resource that is being deleted. In a video resource, the id property specifies the video's ID. - pub fn delete(&self, id: &str) -> VideoDeleteCall<'a, C, NC, A> { + pub fn delete(&self, id: &str) -> VideoDeleteCall<'a, C, A> { VideoDeleteCall { hub: self.hub, _id: id.to_string(), @@ -4779,7 +4775,7 @@ impl<'a, C, NC, A> VideoMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn update(&self, request: &Video) -> VideoUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Video) -> VideoUpdateCall<'a, C, A> { VideoUpdateCall { hub: self.hub, _request: request.clone(), @@ -4798,7 +4794,7 @@ impl<'a, C, NC, A> VideoMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &Video) -> VideoInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Video) -> VideoInsertCall<'a, C, A> { VideoInsertCall { hub: self.hub, _request: request.clone(), @@ -4845,15 +4841,15 @@ impl<'a, C, NC, A> VideoMethods<'a, C, NC, A> { /// let rb = hub.subscriptions(); /// # } /// ``` -pub struct SubscriptionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubscriptionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, } -impl<'a, C, NC, A> MethodsBuilder for SubscriptionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for SubscriptionMethods<'a, C, A> {} -impl<'a, C, NC, A> SubscriptionMethods<'a, C, NC, A> { +impl<'a, C, A> SubscriptionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -4862,7 +4858,7 @@ impl<'a, C, NC, A> SubscriptionMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &Subscription) -> SubscriptionInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Subscription) -> SubscriptionInsertCall<'a, C, A> { SubscriptionInsertCall { hub: self.hub, _request: request.clone(), @@ -4881,7 +4877,7 @@ impl<'a, C, NC, A> SubscriptionMethods<'a, C, NC, A> { /// /// * `part` - The part parameter specifies a comma-separated list of one or more subscription resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, and contentDetails. /// If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a subscription resource, the snippet property contains other properties, such as a display title for the subscription. If you set part=snippet, the API response will also contain all of those nested properties. - pub fn list(&self, part: &str) -> SubscriptionListCall<'a, C, NC, A> { + pub fn list(&self, part: &str) -> SubscriptionListCall<'a, C, A> { SubscriptionListCall { hub: self.hub, _part: part.to_string(), @@ -4908,7 +4904,7 @@ impl<'a, C, NC, A> SubscriptionMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The id parameter specifies the YouTube subscription ID for the resource that is being deleted. In a subscription resource, the id property specifies the YouTube subscription ID. - pub fn delete(&self, id: &str) -> SubscriptionDeleteCall<'a, C, NC, A> { + pub fn delete(&self, id: &str) -> SubscriptionDeleteCall<'a, C, A> { SubscriptionDeleteCall { hub: self.hub, _id: id.to_string(), @@ -4949,15 +4945,15 @@ impl<'a, C, NC, A> SubscriptionMethods<'a, C, NC, A> { /// let rb = hub.search(); /// # } /// ``` -pub struct SearchMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SearchMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, } -impl<'a, C, NC, A> MethodsBuilder for SearchMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for SearchMethods<'a, C, A> {} -impl<'a, C, NC, A> SearchMethods<'a, C, NC, A> { +impl<'a, C, A> SearchMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -4967,7 +4963,7 @@ impl<'a, C, NC, A> SearchMethods<'a, C, NC, A> { /// /// * `part` - The part parameter specifies a comma-separated list of one or more search resource properties that the API response will include. The part names that you can include in the parameter value are id and snippet. /// If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a search result, the snippet property contains other properties that identify the result's title, description, and so forth. If you set part=snippet, the API response will also contain all of those nested properties. - pub fn list(&self, part: &str) -> SearchListCall<'a, C, NC, A> { + pub fn list(&self, part: &str) -> SearchListCall<'a, C, A> { SearchListCall { hub: self.hub, _part: part.to_string(), @@ -5038,15 +5034,15 @@ impl<'a, C, NC, A> SearchMethods<'a, C, NC, A> { /// let rb = hub.i18n_regions(); /// # } /// ``` -pub struct I18nRegionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct I18nRegionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, } -impl<'a, C, NC, A> MethodsBuilder for I18nRegionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for I18nRegionMethods<'a, C, A> {} -impl<'a, C, NC, A> I18nRegionMethods<'a, C, NC, A> { +impl<'a, C, A> I18nRegionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -5055,7 +5051,7 @@ impl<'a, C, NC, A> I18nRegionMethods<'a, C, NC, A> { /// # Arguments /// /// * `part` - The part parameter specifies a comma-separated list of one or more i18nRegion resource properties that the API response will include. The part names that you can include in the parameter value are id and snippet. - pub fn list(&self, part: &str) -> I18nRegionListCall<'a, C, NC, A> { + pub fn list(&self, part: &str) -> I18nRegionListCall<'a, C, A> { I18nRegionListCall { hub: self.hub, _part: part.to_string(), @@ -5097,15 +5093,15 @@ impl<'a, C, NC, A> I18nRegionMethods<'a, C, NC, A> { /// let rb = hub.live_streams(); /// # } /// ``` -pub struct LiveStreamMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LiveStreamMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, } -impl<'a, C, NC, A> MethodsBuilder for LiveStreamMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for LiveStreamMethods<'a, C, A> {} -impl<'a, C, NC, A> LiveStreamMethods<'a, C, NC, A> { +impl<'a, C, A> LiveStreamMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -5114,7 +5110,7 @@ impl<'a, C, NC, A> LiveStreamMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn update(&self, request: &LiveStream) -> LiveStreamUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &LiveStream) -> LiveStreamUpdateCall<'a, C, A> { LiveStreamUpdateCall { hub: self.hub, _request: request.clone(), @@ -5134,7 +5130,7 @@ impl<'a, C, NC, A> LiveStreamMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The id parameter specifies the YouTube live stream ID for the resource that is being deleted. - pub fn delete(&self, id: &str) -> LiveStreamDeleteCall<'a, C, NC, A> { + pub fn delete(&self, id: &str) -> LiveStreamDeleteCall<'a, C, A> { LiveStreamDeleteCall { hub: self.hub, _id: id.to_string(), @@ -5153,7 +5149,7 @@ impl<'a, C, NC, A> LiveStreamMethods<'a, C, NC, A> { /// # Arguments /// /// * `part` - The part parameter specifies a comma-separated list of one or more liveStream resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, cdn, and status. - pub fn list(&self, part: &str) -> LiveStreamListCall<'a, C, NC, A> { + pub fn list(&self, part: &str) -> LiveStreamListCall<'a, C, A> { LiveStreamListCall { hub: self.hub, _part: part.to_string(), @@ -5176,7 +5172,7 @@ impl<'a, C, NC, A> LiveStreamMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &LiveStream) -> LiveStreamInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &LiveStream) -> LiveStreamInsertCall<'a, C, A> { LiveStreamInsertCall { hub: self.hub, _request: request.clone(), @@ -5220,15 +5216,15 @@ impl<'a, C, NC, A> LiveStreamMethods<'a, C, NC, A> { /// let rb = hub.channels(); /// # } /// ``` -pub struct ChannelMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChannelMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, } -impl<'a, C, NC, A> MethodsBuilder for ChannelMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ChannelMethods<'a, C, A> {} -impl<'a, C, NC, A> ChannelMethods<'a, C, NC, A> { +impl<'a, C, A> ChannelMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -5237,7 +5233,7 @@ impl<'a, C, NC, A> ChannelMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn update(&self, request: &Channel) -> ChannelUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Channel) -> ChannelUpdateCall<'a, C, A> { ChannelUpdateCall { hub: self.hub, _request: request.clone(), @@ -5257,7 +5253,7 @@ impl<'a, C, NC, A> ChannelMethods<'a, C, NC, A> { /// /// * `part` - The part parameter specifies a comma-separated list of one or more channel resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, contentDetails, statistics, topicDetails, and invideoPromotion. /// If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a channel resource, the contentDetails property contains other properties, such as the uploads properties. As such, if you set part=contentDetails, the API response will also contain all of those nested properties. - pub fn list(&self, part: &str) -> ChannelListCall<'a, C, NC, A> { + pub fn list(&self, part: &str) -> ChannelListCall<'a, C, A> { ChannelListCall { hub: self.hub, _part: part.to_string(), @@ -5308,15 +5304,15 @@ impl<'a, C, NC, A> ChannelMethods<'a, C, NC, A> { /// let rb = hub.playlist_items(); /// # } /// ``` -pub struct PlaylistItemMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlaylistItemMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, } -impl<'a, C, NC, A> MethodsBuilder for PlaylistItemMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for PlaylistItemMethods<'a, C, A> {} -impl<'a, C, NC, A> PlaylistItemMethods<'a, C, NC, A> { +impl<'a, C, A> PlaylistItemMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -5325,7 +5321,7 @@ impl<'a, C, NC, A> PlaylistItemMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &PlaylistItem) -> PlaylistItemInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &PlaylistItem) -> PlaylistItemInsertCall<'a, C, A> { PlaylistItemInsertCall { hub: self.hub, _request: request.clone(), @@ -5344,7 +5340,7 @@ impl<'a, C, NC, A> PlaylistItemMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The id parameter specifies the YouTube playlist item ID for the playlist item that is being deleted. In a playlistItem resource, the id property specifies the playlist item's ID. - pub fn delete(&self, id: &str) -> PlaylistItemDeleteCall<'a, C, NC, A> { + pub fn delete(&self, id: &str) -> PlaylistItemDeleteCall<'a, C, A> { PlaylistItemDeleteCall { hub: self.hub, _id: id.to_string(), @@ -5362,7 +5358,7 @@ impl<'a, C, NC, A> PlaylistItemMethods<'a, C, NC, A> { /// /// * `part` - The part parameter specifies a comma-separated list of one or more playlistItem resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, contentDetails, and status. /// If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a playlistItem resource, the snippet property contains numerous fields, including the title, description, position, and resourceId properties. As such, if you set part=snippet, the API response will contain all of those properties. - pub fn list(&self, part: &str) -> PlaylistItemListCall<'a, C, NC, A> { + pub fn list(&self, part: &str) -> PlaylistItemListCall<'a, C, A> { PlaylistItemListCall { hub: self.hub, _part: part.to_string(), @@ -5385,7 +5381,7 @@ impl<'a, C, NC, A> PlaylistItemMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn update(&self, request: &PlaylistItem) -> PlaylistItemUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &PlaylistItem) -> PlaylistItemUpdateCall<'a, C, A> { PlaylistItemUpdateCall { hub: self.hub, _request: request.clone(), @@ -5427,15 +5423,15 @@ impl<'a, C, NC, A> PlaylistItemMethods<'a, C, NC, A> { /// let rb = hub.watermarks(); /// # } /// ``` -pub struct WatermarkMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct WatermarkMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, } -impl<'a, C, NC, A> MethodsBuilder for WatermarkMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for WatermarkMethods<'a, C, A> {} -impl<'a, C, NC, A> WatermarkMethods<'a, C, NC, A> { +impl<'a, C, A> WatermarkMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -5445,7 +5441,7 @@ impl<'a, C, NC, A> WatermarkMethods<'a, C, NC, A> { /// /// * `request` - No description provided. /// * `channelId` - The channelId parameter specifies a YouTube channel ID for which the watermark is being provided. - pub fn set(&self, request: &InvideoBranding, channel_id: &str) -> WatermarkSetCall<'a, C, NC, A> { + pub fn set(&self, request: &InvideoBranding, channel_id: &str) -> WatermarkSetCall<'a, C, A> { WatermarkSetCall { hub: self.hub, _request: request.clone(), @@ -5464,7 +5460,7 @@ impl<'a, C, NC, A> WatermarkMethods<'a, C, NC, A> { /// # Arguments /// /// * `channelId` - The channelId parameter specifies a YouTube channel ID for which the watermark is being unset. - pub fn unset(&self, channel_id: &str) -> WatermarkUnsetCall<'a, C, NC, A> { + pub fn unset(&self, channel_id: &str) -> WatermarkUnsetCall<'a, C, A> { WatermarkUnsetCall { hub: self.hub, _channel_id: channel_id.to_string(), @@ -5506,15 +5502,15 @@ impl<'a, C, NC, A> WatermarkMethods<'a, C, NC, A> { /// let rb = hub.live_broadcasts(); /// # } /// ``` -pub struct LiveBroadcastMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LiveBroadcastMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, } -impl<'a, C, NC, A> MethodsBuilder for LiveBroadcastMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for LiveBroadcastMethods<'a, C, A> {} -impl<'a, C, NC, A> LiveBroadcastMethods<'a, C, NC, A> { +impl<'a, C, A> LiveBroadcastMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -5524,7 +5520,7 @@ impl<'a, C, NC, A> LiveBroadcastMethods<'a, C, NC, A> { /// /// * `id` - The id parameter specifies the YouTube live broadcast ID that uniquely identifies the broadcast in which the slate is being updated. /// * `part` - The part parameter specifies a comma-separated list of one or more liveBroadcast resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, contentDetails, and status. - pub fn control(&self, id: &str, part: &str) -> LiveBroadcastControlCall<'a, C, NC, A> { + pub fn control(&self, id: &str, part: &str) -> LiveBroadcastControlCall<'a, C, A> { LiveBroadcastControlCall { hub: self.hub, _id: id.to_string(), @@ -5547,7 +5543,7 @@ impl<'a, C, NC, A> LiveBroadcastMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn update(&self, request: &LiveBroadcast) -> LiveBroadcastUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &LiveBroadcast) -> LiveBroadcastUpdateCall<'a, C, A> { LiveBroadcastUpdateCall { hub: self.hub, _request: request.clone(), @@ -5567,7 +5563,7 @@ impl<'a, C, NC, A> LiveBroadcastMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &LiveBroadcast) -> LiveBroadcastInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &LiveBroadcast) -> LiveBroadcastInsertCall<'a, C, A> { LiveBroadcastInsertCall { hub: self.hub, _request: request.clone(), @@ -5588,7 +5584,7 @@ impl<'a, C, NC, A> LiveBroadcastMethods<'a, C, NC, A> { /// /// * `id` - The id parameter specifies the unique ID of the broadcast that is being bound to a video stream. /// * `part` - The part parameter specifies a comma-separated list of one or more liveBroadcast resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, contentDetails, and status. - pub fn bind(&self, id: &str, part: &str) -> LiveBroadcastBindCall<'a, C, NC, A> { + pub fn bind(&self, id: &str, part: &str) -> LiveBroadcastBindCall<'a, C, A> { LiveBroadcastBindCall { hub: self.hub, _id: id.to_string(), @@ -5609,7 +5605,7 @@ impl<'a, C, NC, A> LiveBroadcastMethods<'a, C, NC, A> { /// # Arguments /// /// * `part` - The part parameter specifies a comma-separated list of one or more liveBroadcast resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, contentDetails, and status. - pub fn list(&self, part: &str) -> LiveBroadcastListCall<'a, C, NC, A> { + pub fn list(&self, part: &str) -> LiveBroadcastListCall<'a, C, A> { LiveBroadcastListCall { hub: self.hub, _part: part.to_string(), @@ -5633,7 +5629,7 @@ impl<'a, C, NC, A> LiveBroadcastMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The id parameter specifies the YouTube live broadcast ID for the resource that is being deleted. - pub fn delete(&self, id: &str) -> LiveBroadcastDeleteCall<'a, C, NC, A> { + pub fn delete(&self, id: &str) -> LiveBroadcastDeleteCall<'a, C, A> { LiveBroadcastDeleteCall { hub: self.hub, _id: id.to_string(), @@ -5654,7 +5650,7 @@ impl<'a, C, NC, A> LiveBroadcastMethods<'a, C, NC, A> { /// * `broadcastStatus` - The broadcastStatus parameter identifies the state to which the broadcast is changing. Note that to transition a broadcast to either the testing or live state, the status.streamStatus must be active for the stream that the broadcast is bound to. /// * `id` - The id parameter specifies the unique ID of the broadcast that is transitioning to another status. /// * `part` - The part parameter specifies a comma-separated list of one or more liveBroadcast resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, contentDetails, and status. - pub fn transition(&self, broadcast_status: &str, id: &str, part: &str) -> LiveBroadcastTransitionCall<'a, C, NC, A> { + pub fn transition(&self, broadcast_status: &str, id: &str, part: &str) -> LiveBroadcastTransitionCall<'a, C, A> { LiveBroadcastTransitionCall { hub: self.hub, _broadcast_status: broadcast_status.to_string(), @@ -5699,15 +5695,15 @@ impl<'a, C, NC, A> LiveBroadcastMethods<'a, C, NC, A> { /// let rb = hub.captions(); /// # } /// ``` -pub struct CaptionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CaptionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, } -impl<'a, C, NC, A> MethodsBuilder for CaptionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for CaptionMethods<'a, C, A> {} -impl<'a, C, NC, A> CaptionMethods<'a, C, NC, A> { +impl<'a, C, A> CaptionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -5716,7 +5712,7 @@ impl<'a, C, NC, A> CaptionMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The id parameter identifies the caption track that is being deleted. The value is a caption track ID as identified by the id property in a caption resource. - pub fn delete(&self, id: &str) -> CaptionDeleteCall<'a, C, NC, A> { + pub fn delete(&self, id: &str) -> CaptionDeleteCall<'a, C, A> { CaptionDeleteCall { hub: self.hub, _id: id.to_string(), @@ -5735,7 +5731,7 @@ impl<'a, C, NC, A> CaptionMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &Caption) -> CaptionInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Caption) -> CaptionInsertCall<'a, C, A> { CaptionInsertCall { hub: self.hub, _request: request.clone(), @@ -5757,7 +5753,7 @@ impl<'a, C, NC, A> CaptionMethods<'a, C, NC, A> { /// /// * `part` - The part parameter specifies the caption resource parts that the API response will include. /// * `videoId` - The videoId parameter specifies the YouTube video ID of the video for which the API should return caption tracks. - pub fn list(&self, part: &str, video_id: &str) -> CaptionListCall<'a, C, NC, A> { + pub fn list(&self, part: &str, video_id: &str) -> CaptionListCall<'a, C, A> { CaptionListCall { hub: self.hub, _part: part.to_string(), @@ -5778,7 +5774,7 @@ impl<'a, C, NC, A> CaptionMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The id parameter identifies the caption track that is being retrieved. The value is a caption track ID as identified by the id property in a caption resource. - pub fn download(&self, id: &str) -> CaptionDownloadCall<'a, C, NC, A> { + pub fn download(&self, id: &str) -> CaptionDownloadCall<'a, C, A> { CaptionDownloadCall { hub: self.hub, _id: id.to_string(), @@ -5799,7 +5795,7 @@ impl<'a, C, NC, A> CaptionMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn update(&self, request: &Caption) -> CaptionUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Caption) -> CaptionUpdateCall<'a, C, A> { CaptionUpdateCall { hub: self.hub, _request: request.clone(), @@ -5844,15 +5840,15 @@ impl<'a, C, NC, A> CaptionMethods<'a, C, NC, A> { /// let rb = hub.video_categories(); /// # } /// ``` -pub struct VideoCategoryMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VideoCategoryMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, } -impl<'a, C, NC, A> MethodsBuilder for VideoCategoryMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for VideoCategoryMethods<'a, C, A> {} -impl<'a, C, NC, A> VideoCategoryMethods<'a, C, NC, A> { +impl<'a, C, A> VideoCategoryMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -5861,7 +5857,7 @@ impl<'a, C, NC, A> VideoCategoryMethods<'a, C, NC, A> { /// # Arguments /// /// * `part` - The part parameter specifies the videoCategory resource parts that the API response will include. Supported values are id and snippet. - pub fn list(&self, part: &str) -> VideoCategoryListCall<'a, C, NC, A> { + pub fn list(&self, part: &str) -> VideoCategoryListCall<'a, C, A> { VideoCategoryListCall { hub: self.hub, _part: part.to_string(), @@ -5905,15 +5901,15 @@ impl<'a, C, NC, A> VideoCategoryMethods<'a, C, NC, A> { /// let rb = hub.activities(); /// # } /// ``` -pub struct ActivityMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ActivityMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, } -impl<'a, C, NC, A> MethodsBuilder for ActivityMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ActivityMethods<'a, C, A> {} -impl<'a, C, NC, A> ActivityMethods<'a, C, NC, A> { +impl<'a, C, A> ActivityMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -5923,7 +5919,7 @@ impl<'a, C, NC, A> ActivityMethods<'a, C, NC, A> { /// /// * `part` - The part parameter specifies a comma-separated list of one or more activity resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, and contentDetails. /// If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a activity resource, the snippet property contains other properties that identify the type of activity, a display title for the activity, and so forth. If you set part=snippet, the API response will also contain all of those nested properties. - pub fn list(&self, part: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn list(&self, part: &str) -> ActivityListCall<'a, C, A> { ActivityListCall { hub: self.hub, _part: part.to_string(), @@ -5950,7 +5946,7 @@ impl<'a, C, NC, A> ActivityMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &Activity) -> ActivityInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Activity) -> ActivityInsertCall<'a, C, A> { ActivityInsertCall { hub: self.hub, _request: request.clone(), @@ -6015,10 +6011,10 @@ impl<'a, C, NC, A> ActivityMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct I18nLanguageListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct I18nLanguageListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _part: String, _hl: Option, _delegate: Option<&'a mut Delegate>, @@ -6026,9 +6022,9 @@ pub struct I18nLanguageListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for I18nLanguageListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for I18nLanguageListCall<'a, C, A> {} -impl<'a, C, NC, A> I18nLanguageListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> I18nLanguageListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6144,7 +6140,7 @@ impl<'a, C, NC, A> I18nLanguageListCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *snippet* /// /// The part parameter specifies a comma-separated list of one or more i18nLanguage resource properties that the API response will include. The part names that you can include in the parameter value are id and snippet. - pub fn part(mut self, new_value: &str) -> I18nLanguageListCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> I18nLanguageListCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -6152,7 +6148,7 @@ impl<'a, C, NC, A> I18nLanguageListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The hl parameter specifies the language that should be used for text values in the API response. - pub fn hl(mut self, new_value: &str) -> I18nLanguageListCall<'a, C, NC, A> { + pub fn hl(mut self, new_value: &str) -> I18nLanguageListCall<'a, C, A> { self._hl = Some(new_value.to_string()); self } @@ -6163,7 +6159,7 @@ impl<'a, C, NC, A> I18nLanguageListCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> I18nLanguageListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> I18nLanguageListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6184,7 +6180,7 @@ impl<'a, C, NC, A> I18nLanguageListCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> I18nLanguageListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> I18nLanguageListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6201,7 +6197,7 @@ impl<'a, C, NC, A> I18nLanguageListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> I18nLanguageListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> I18nLanguageListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6251,10 +6247,10 @@ impl<'a, C, NC, A> I18nLanguageListCall<'a, C, NC, A> where NC: hyper::net::Netw /// .upload(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct ChannelBannerInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChannelBannerInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _request: ChannelBannerResource, _on_behalf_of_content_owner: Option, _delegate: Option<&'a mut Delegate>, @@ -6262,9 +6258,9 @@ pub struct ChannelBannerInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChannelBannerInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChannelBannerInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ChannelBannerInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChannelBannerInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6495,7 +6491,7 @@ impl<'a, C, NC, A> ChannelBannerInsertCall<'a, C, NC, A> where NC: hyper::net::N /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &ChannelBannerResource) -> ChannelBannerInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ChannelBannerResource) -> ChannelBannerInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -6505,7 +6501,7 @@ impl<'a, C, NC, A> ChannelBannerInsertCall<'a, C, NC, A> where NC: hyper::net::N /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> ChannelBannerInsertCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> ChannelBannerInsertCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -6516,7 +6512,7 @@ impl<'a, C, NC, A> ChannelBannerInsertCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelBannerInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelBannerInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6537,7 +6533,7 @@ impl<'a, C, NC, A> ChannelBannerInsertCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChannelBannerInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChannelBannerInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6554,7 +6550,7 @@ impl<'a, C, NC, A> ChannelBannerInsertCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChannelBannerInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChannelBannerInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6612,10 +6608,10 @@ impl<'a, C, NC, A> ChannelBannerInsertCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct ChannelSectionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChannelSectionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _part: String, _on_behalf_of_content_owner: Option, _mine: Option, @@ -6627,9 +6623,9 @@ pub struct ChannelSectionListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChannelSectionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChannelSectionListCall<'a, C, A> {} -impl<'a, C, NC, A> ChannelSectionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChannelSectionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -6760,7 +6756,7 @@ impl<'a, C, NC, A> ChannelSectionListCall<'a, C, NC, A> where NC: hyper::net::Ne /// The part parameter specifies a comma-separated list of one or more channelSection resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, and contentDetails. /// /// If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a channelSection resource, the snippet property contains other properties, such as a display title for the channelSection. If you set part=snippet, the API response will also contain all of those nested properties. - pub fn part(mut self, new_value: &str) -> ChannelSectionListCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> ChannelSectionListCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -6770,7 +6766,7 @@ impl<'a, C, NC, A> ChannelSectionListCall<'a, C, NC, A> where NC: hyper::net::Ne /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> ChannelSectionListCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> ChannelSectionListCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -6778,7 +6774,7 @@ impl<'a, C, NC, A> ChannelSectionListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// Set this parameter's value to true to retrieve a feed of the authenticated user's channelSections. - pub fn mine(mut self, new_value: bool) -> ChannelSectionListCall<'a, C, NC, A> { + pub fn mine(mut self, new_value: bool) -> ChannelSectionListCall<'a, C, A> { self._mine = Some(new_value); self } @@ -6786,7 +6782,7 @@ impl<'a, C, NC, A> ChannelSectionListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// The id parameter specifies a comma-separated list of the YouTube channelSection ID(s) for the resource(s) that are being retrieved. In a channelSection resource, the id property specifies the YouTube channelSection ID. - pub fn id(mut self, new_value: &str) -> ChannelSectionListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> ChannelSectionListCall<'a, C, A> { self._id = Some(new_value.to_string()); self } @@ -6794,7 +6790,7 @@ impl<'a, C, NC, A> ChannelSectionListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// The hl parameter indicates that the snippet.localized property values in the returned channelSection resources should be in the specified language if localized values for that language are available. For example, if the API request specifies hl=de, the snippet.localized properties in the API response will contain German titles if German titles are available. Channel owners can provide localized channel section titles using either the channelSections.insert or channelSections.update method. - pub fn hl(mut self, new_value: &str) -> ChannelSectionListCall<'a, C, NC, A> { + pub fn hl(mut self, new_value: &str) -> ChannelSectionListCall<'a, C, A> { self._hl = Some(new_value.to_string()); self } @@ -6802,7 +6798,7 @@ impl<'a, C, NC, A> ChannelSectionListCall<'a, C, NC, A> where NC: hyper::net::Ne /// /// /// The channelId parameter specifies a YouTube channel ID. The API will only return that channel's channelSections. - pub fn channel_id(mut self, new_value: &str) -> ChannelSectionListCall<'a, C, NC, A> { + pub fn channel_id(mut self, new_value: &str) -> ChannelSectionListCall<'a, C, A> { self._channel_id = Some(new_value.to_string()); self } @@ -6813,7 +6809,7 @@ impl<'a, C, NC, A> ChannelSectionListCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelSectionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelSectionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -6834,7 +6830,7 @@ impl<'a, C, NC, A> ChannelSectionListCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChannelSectionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChannelSectionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -6851,7 +6847,7 @@ impl<'a, C, NC, A> ChannelSectionListCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChannelSectionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChannelSectionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -6912,10 +6908,10 @@ impl<'a, C, NC, A> ChannelSectionListCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct ChannelSectionInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChannelSectionInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _request: ChannelSection, _part: String, _on_behalf_of_content_owner_channel: Option, @@ -6925,9 +6921,9 @@ pub struct ChannelSectionInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChannelSectionInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChannelSectionInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ChannelSectionInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChannelSectionInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7056,7 +7052,7 @@ impl<'a, C, NC, A> ChannelSectionInsertCall<'a, C, NC, A> where NC: hyper::net:: /// * *snippet* /// * *contentDetails* /// - pub fn request(mut self, new_value: &ChannelSection) -> ChannelSectionInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ChannelSection) -> ChannelSectionInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7076,7 +7072,7 @@ impl<'a, C, NC, A> ChannelSectionInsertCall<'a, C, NC, A> where NC: hyper::net:: /// The part parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include. /// /// The part names that you can include in the parameter value are snippet and contentDetails. - pub fn part(mut self, new_value: &str) -> ChannelSectionInsertCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> ChannelSectionInsertCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -7088,7 +7084,7 @@ impl<'a, C, NC, A> ChannelSectionInsertCall<'a, C, NC, A> where NC: hyper::net:: /// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. /// /// This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel. - pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> ChannelSectionInsertCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> ChannelSectionInsertCall<'a, C, A> { self._on_behalf_of_content_owner_channel = Some(new_value.to_string()); self } @@ -7098,7 +7094,7 @@ impl<'a, C, NC, A> ChannelSectionInsertCall<'a, C, NC, A> where NC: hyper::net:: /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> ChannelSectionInsertCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> ChannelSectionInsertCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -7109,7 +7105,7 @@ impl<'a, C, NC, A> ChannelSectionInsertCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelSectionInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelSectionInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7130,7 +7126,7 @@ impl<'a, C, NC, A> ChannelSectionInsertCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChannelSectionInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChannelSectionInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7147,7 +7143,7 @@ impl<'a, C, NC, A> ChannelSectionInsertCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChannelSectionInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChannelSectionInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7186,10 +7182,10 @@ impl<'a, C, NC, A> ChannelSectionInsertCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct ChannelSectionDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChannelSectionDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _id: String, _on_behalf_of_content_owner: Option, _delegate: Option<&'a mut Delegate>, @@ -7197,9 +7193,9 @@ pub struct ChannelSectionDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChannelSectionDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChannelSectionDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> ChannelSectionDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChannelSectionDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7299,7 +7295,7 @@ impl<'a, C, NC, A> ChannelSectionDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The id parameter specifies the YouTube channelSection ID for the resource that is being deleted. In a channelSection resource, the id property specifies the YouTube channelSection ID. - pub fn id(mut self, new_value: &str) -> ChannelSectionDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> ChannelSectionDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -7309,7 +7305,7 @@ impl<'a, C, NC, A> ChannelSectionDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> ChannelSectionDeleteCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> ChannelSectionDeleteCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -7320,7 +7316,7 @@ impl<'a, C, NC, A> ChannelSectionDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelSectionDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelSectionDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7341,7 +7337,7 @@ impl<'a, C, NC, A> ChannelSectionDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChannelSectionDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChannelSectionDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7358,7 +7354,7 @@ impl<'a, C, NC, A> ChannelSectionDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChannelSectionDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChannelSectionDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7418,10 +7414,10 @@ impl<'a, C, NC, A> ChannelSectionDeleteCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct ChannelSectionUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChannelSectionUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _request: ChannelSection, _part: String, _on_behalf_of_content_owner: Option, @@ -7430,9 +7426,9 @@ pub struct ChannelSectionUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChannelSectionUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChannelSectionUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ChannelSectionUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChannelSectionUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7558,7 +7554,7 @@ impl<'a, C, NC, A> ChannelSectionUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// * *snippet* /// * *contentDetails* /// - pub fn request(mut self, new_value: &ChannelSection) -> ChannelSectionUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &ChannelSection) -> ChannelSectionUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -7578,7 +7574,7 @@ impl<'a, C, NC, A> ChannelSectionUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// The part parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include. /// /// The part names that you can include in the parameter value are snippet and contentDetails. - pub fn part(mut self, new_value: &str) -> ChannelSectionUpdateCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> ChannelSectionUpdateCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -7588,7 +7584,7 @@ impl<'a, C, NC, A> ChannelSectionUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> ChannelSectionUpdateCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> ChannelSectionUpdateCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -7599,7 +7595,7 @@ impl<'a, C, NC, A> ChannelSectionUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelSectionUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelSectionUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7620,7 +7616,7 @@ impl<'a, C, NC, A> ChannelSectionUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChannelSectionUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChannelSectionUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7637,7 +7633,7 @@ impl<'a, C, NC, A> ChannelSectionUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChannelSectionUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChannelSectionUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7692,10 +7688,10 @@ impl<'a, C, NC, A> ChannelSectionUpdateCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct GuideCategoryListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GuideCategoryListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _part: String, _region_code: Option, _id: Option, @@ -7705,9 +7701,9 @@ pub struct GuideCategoryListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GuideCategoryListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GuideCategoryListCall<'a, C, A> {} -impl<'a, C, NC, A> GuideCategoryListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GuideCategoryListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -7831,7 +7827,7 @@ impl<'a, C, NC, A> GuideCategoryListCall<'a, C, NC, A> where NC: hyper::net::Net /// The part parameter specifies a comma-separated list of one or more guideCategory resource properties that the API response will include. The part names that you can include in the parameter value are id and snippet. /// /// If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a guideCategory resource, the snippet property contains other properties, such as the category's title. If you set part=snippet, the API response will also contain all of those nested properties. - pub fn part(mut self, new_value: &str) -> GuideCategoryListCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> GuideCategoryListCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -7839,7 +7835,7 @@ impl<'a, C, NC, A> GuideCategoryListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The regionCode parameter instructs the API to return the list of guide categories available in the specified country. The parameter value is an ISO 3166-1 alpha-2 country code. - pub fn region_code(mut self, new_value: &str) -> GuideCategoryListCall<'a, C, NC, A> { + pub fn region_code(mut self, new_value: &str) -> GuideCategoryListCall<'a, C, A> { self._region_code = Some(new_value.to_string()); self } @@ -7847,7 +7843,7 @@ impl<'a, C, NC, A> GuideCategoryListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The id parameter specifies a comma-separated list of the YouTube channel category ID(s) for the resource(s) that are being retrieved. In a guideCategory resource, the id property specifies the YouTube channel category ID. - pub fn id(mut self, new_value: &str) -> GuideCategoryListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> GuideCategoryListCall<'a, C, A> { self._id = Some(new_value.to_string()); self } @@ -7855,7 +7851,7 @@ impl<'a, C, NC, A> GuideCategoryListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The hl parameter specifies the language that will be used for text values in the API response. - pub fn hl(mut self, new_value: &str) -> GuideCategoryListCall<'a, C, NC, A> { + pub fn hl(mut self, new_value: &str) -> GuideCategoryListCall<'a, C, A> { self._hl = Some(new_value.to_string()); self } @@ -7866,7 +7862,7 @@ impl<'a, C, NC, A> GuideCategoryListCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GuideCategoryListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GuideCategoryListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -7887,7 +7883,7 @@ impl<'a, C, NC, A> GuideCategoryListCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GuideCategoryListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GuideCategoryListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -7904,7 +7900,7 @@ impl<'a, C, NC, A> GuideCategoryListCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GuideCategoryListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GuideCategoryListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -7965,10 +7961,10 @@ impl<'a, C, NC, A> GuideCategoryListCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct PlaylistInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlaylistInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _request: Playlist, _part: String, _on_behalf_of_content_owner_channel: Option, @@ -7978,9 +7974,9 @@ pub struct PlaylistInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlaylistInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlaylistInsertCall<'a, C, A> {} -impl<'a, C, NC, A> PlaylistInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlaylistInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8109,7 +8105,7 @@ impl<'a, C, NC, A> PlaylistInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *snippet* /// * *status* /// - pub fn request(mut self, new_value: &Playlist) -> PlaylistInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Playlist) -> PlaylistInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8129,7 +8125,7 @@ impl<'a, C, NC, A> PlaylistInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// The part parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include. /// /// The part names that you can include in the parameter value are snippet and status. - pub fn part(mut self, new_value: &str) -> PlaylistInsertCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> PlaylistInsertCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -8141,7 +8137,7 @@ impl<'a, C, NC, A> PlaylistInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. /// /// This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel. - pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> PlaylistInsertCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> PlaylistInsertCall<'a, C, A> { self._on_behalf_of_content_owner_channel = Some(new_value.to_string()); self } @@ -8151,7 +8147,7 @@ impl<'a, C, NC, A> PlaylistInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> PlaylistInsertCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> PlaylistInsertCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -8162,7 +8158,7 @@ impl<'a, C, NC, A> PlaylistInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlaylistInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlaylistInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8183,7 +8179,7 @@ impl<'a, C, NC, A> PlaylistInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlaylistInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlaylistInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8200,7 +8196,7 @@ impl<'a, C, NC, A> PlaylistInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlaylistInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlaylistInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8262,10 +8258,10 @@ impl<'a, C, NC, A> PlaylistInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct PlaylistListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlaylistListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _part: String, _page_token: Option, _on_behalf_of_content_owner_channel: Option, @@ -8280,9 +8276,9 @@ pub struct PlaylistListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlaylistListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlaylistListCall<'a, C, A> {} -impl<'a, C, NC, A> PlaylistListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlaylistListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8423,7 +8419,7 @@ impl<'a, C, NC, A> PlaylistListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// The part parameter specifies a comma-separated list of one or more playlist resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, status, and contentDetails. /// /// If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a playlist resource, the snippet property contains properties like author, title, description, tags, and timeCreated. As such, if you set part=snippet, the API response will contain all of those properties. - pub fn part(mut self, new_value: &str) -> PlaylistListCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> PlaylistListCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -8431,7 +8427,7 @@ impl<'a, C, NC, A> PlaylistListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The pageToken parameter identifies a specific page in the result set that should be returned. In an API response, the nextPageToken and prevPageToken properties identify other pages that could be retrieved. - pub fn page_token(mut self, new_value: &str) -> PlaylistListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> PlaylistListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -8443,7 +8439,7 @@ impl<'a, C, NC, A> PlaylistListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. /// /// This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel. - pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> PlaylistListCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> PlaylistListCall<'a, C, A> { self._on_behalf_of_content_owner_channel = Some(new_value.to_string()); self } @@ -8453,7 +8449,7 @@ impl<'a, C, NC, A> PlaylistListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> PlaylistListCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> PlaylistListCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -8461,7 +8457,7 @@ impl<'a, C, NC, A> PlaylistListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Set this parameter's value to true to instruct the API to only return playlists owned by the authenticated user. - pub fn mine(mut self, new_value: bool) -> PlaylistListCall<'a, C, NC, A> { + pub fn mine(mut self, new_value: bool) -> PlaylistListCall<'a, C, A> { self._mine = Some(new_value); self } @@ -8469,7 +8465,7 @@ impl<'a, C, NC, A> PlaylistListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The maxResults parameter specifies the maximum number of items that should be returned in the result set. - pub fn max_results(mut self, new_value: u32) -> PlaylistListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> PlaylistListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -8477,7 +8473,7 @@ impl<'a, C, NC, A> PlaylistListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The id parameter specifies a comma-separated list of the YouTube playlist ID(s) for the resource(s) that are being retrieved. In a playlist resource, the id property specifies the playlist's YouTube playlist ID. - pub fn id(mut self, new_value: &str) -> PlaylistListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> PlaylistListCall<'a, C, A> { self._id = Some(new_value.to_string()); self } @@ -8485,7 +8481,7 @@ impl<'a, C, NC, A> PlaylistListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The hl parameter should be used for filter out the properties that are not in the given language. Used for the snippet part. - pub fn hl(mut self, new_value: &str) -> PlaylistListCall<'a, C, NC, A> { + pub fn hl(mut self, new_value: &str) -> PlaylistListCall<'a, C, A> { self._hl = Some(new_value.to_string()); self } @@ -8493,7 +8489,7 @@ impl<'a, C, NC, A> PlaylistListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// This value indicates that the API should only return the specified channel's playlists. - pub fn channel_id(mut self, new_value: &str) -> PlaylistListCall<'a, C, NC, A> { + pub fn channel_id(mut self, new_value: &str) -> PlaylistListCall<'a, C, A> { self._channel_id = Some(new_value.to_string()); self } @@ -8504,7 +8500,7 @@ impl<'a, C, NC, A> PlaylistListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlaylistListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlaylistListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8525,7 +8521,7 @@ impl<'a, C, NC, A> PlaylistListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlaylistListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlaylistListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8542,7 +8538,7 @@ impl<'a, C, NC, A> PlaylistListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlaylistListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlaylistListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8581,10 +8577,10 @@ impl<'a, C, NC, A> PlaylistListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct PlaylistDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlaylistDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _id: String, _on_behalf_of_content_owner: Option, _delegate: Option<&'a mut Delegate>, @@ -8592,9 +8588,9 @@ pub struct PlaylistDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlaylistDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlaylistDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> PlaylistDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlaylistDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8694,7 +8690,7 @@ impl<'a, C, NC, A> PlaylistDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The id parameter specifies the YouTube playlist ID for the playlist that is being deleted. In a playlist resource, the id property specifies the playlist's ID. - pub fn id(mut self, new_value: &str) -> PlaylistDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> PlaylistDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -8704,7 +8700,7 @@ impl<'a, C, NC, A> PlaylistDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> PlaylistDeleteCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> PlaylistDeleteCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -8715,7 +8711,7 @@ impl<'a, C, NC, A> PlaylistDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlaylistDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlaylistDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -8736,7 +8732,7 @@ impl<'a, C, NC, A> PlaylistDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlaylistDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlaylistDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -8753,7 +8749,7 @@ impl<'a, C, NC, A> PlaylistDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlaylistDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlaylistDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -8813,10 +8809,10 @@ impl<'a, C, NC, A> PlaylistDeleteCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct PlaylistUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlaylistUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _request: Playlist, _part: String, _on_behalf_of_content_owner: Option, @@ -8825,9 +8821,9 @@ pub struct PlaylistUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlaylistUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlaylistUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> PlaylistUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlaylistUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -8953,7 +8949,7 @@ impl<'a, C, NC, A> PlaylistUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *snippet* /// * *status* /// - pub fn request(mut self, new_value: &Playlist) -> PlaylistUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Playlist) -> PlaylistUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -8975,7 +8971,7 @@ impl<'a, C, NC, A> PlaylistUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// The part names that you can include in the parameter value are snippet and status. /// /// Note that this method will override the existing values for all of the mutable properties that are contained in any parts that the parameter value specifies. For example, a playlist's privacy setting is contained in the status part. As such, if your request is updating a private playlist, and the request's part parameter value includes the status part, the playlist's privacy setting will be updated to whatever value the request body specifies. If the request body does not specify a value, the existing privacy setting will be removed and the playlist will revert to the default privacy setting. - pub fn part(mut self, new_value: &str) -> PlaylistUpdateCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> PlaylistUpdateCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -8985,7 +8981,7 @@ impl<'a, C, NC, A> PlaylistUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> PlaylistUpdateCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> PlaylistUpdateCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -8996,7 +8992,7 @@ impl<'a, C, NC, A> PlaylistUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlaylistUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlaylistUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9017,7 +9013,7 @@ impl<'a, C, NC, A> PlaylistUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlaylistUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlaylistUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9034,7 +9030,7 @@ impl<'a, C, NC, A> PlaylistUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlaylistUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlaylistUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9074,10 +9070,10 @@ impl<'a, C, NC, A> PlaylistUpdateCall<'a, C, NC, A> where NC: hyper::net::Networ /// .upload(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct ThumbnailSetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ThumbnailSetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _video_id: String, _on_behalf_of_content_owner: Option, _delegate: Option<&'a mut Delegate>, @@ -9085,9 +9081,9 @@ pub struct ThumbnailSetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ThumbnailSetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ThumbnailSetCall<'a, C, A> {} -impl<'a, C, NC, A> ThumbnailSetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ThumbnailSetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9307,7 +9303,7 @@ impl<'a, C, NC, A> ThumbnailSetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The videoId parameter specifies a YouTube video ID for which the custom video thumbnail is being provided. - pub fn video_id(mut self, new_value: &str) -> ThumbnailSetCall<'a, C, NC, A> { + pub fn video_id(mut self, new_value: &str) -> ThumbnailSetCall<'a, C, A> { self._video_id = new_value.to_string(); self } @@ -9315,7 +9311,7 @@ impl<'a, C, NC, A> ThumbnailSetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The onBehalfOfContentOwner parameter indicates that the authenticated user is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The actual CMS account that the user authenticates with needs to be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> ThumbnailSetCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> ThumbnailSetCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -9326,7 +9322,7 @@ impl<'a, C, NC, A> ThumbnailSetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ThumbnailSetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ThumbnailSetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9347,7 +9343,7 @@ impl<'a, C, NC, A> ThumbnailSetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ThumbnailSetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ThumbnailSetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9364,7 +9360,7 @@ impl<'a, C, NC, A> ThumbnailSetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ThumbnailSetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ThumbnailSetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9437,10 +9433,10 @@ impl<'a, C, NC, A> ThumbnailSetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct VideoListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VideoListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _part: String, _video_category_id: Option, _region_code: Option, @@ -9457,9 +9453,9 @@ pub struct VideoListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VideoListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VideoListCall<'a, C, A> {} -impl<'a, C, NC, A> VideoListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VideoListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9615,7 +9611,7 @@ impl<'a, C, NC, A> VideoListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// The part parameter specifies a comma-separated list of one or more video resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, contentDetails, fileDetails, liveStreamingDetails, localizations, player, processingDetails, recordingDetails, statistics, status, suggestions, and topicDetails. /// /// If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a video resource, the snippet property contains the channelId, title, description, tags, and categoryId properties. As such, if you set part=snippet, the API response will contain all of those properties. - pub fn part(mut self, new_value: &str) -> VideoListCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> VideoListCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -9623,7 +9619,7 @@ impl<'a, C, NC, A> VideoListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The videoCategoryId parameter identifies the video category for which the chart should be retrieved. This parameter can only be used in conjunction with the chart parameter. By default, charts are not restricted to a particular category. - pub fn video_category_id(mut self, new_value: &str) -> VideoListCall<'a, C, NC, A> { + pub fn video_category_id(mut self, new_value: &str) -> VideoListCall<'a, C, A> { self._video_category_id = Some(new_value.to_string()); self } @@ -9631,7 +9627,7 @@ impl<'a, C, NC, A> VideoListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The regionCode parameter instructs the API to select a video chart available in the specified region. This parameter can only be used in conjunction with the chart parameter. The parameter value is an ISO 3166-1 alpha-2 country code. - pub fn region_code(mut self, new_value: &str) -> VideoListCall<'a, C, NC, A> { + pub fn region_code(mut self, new_value: &str) -> VideoListCall<'a, C, A> { self._region_code = Some(new_value.to_string()); self } @@ -9641,7 +9637,7 @@ impl<'a, C, NC, A> VideoListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// The pageToken parameter identifies a specific page in the result set that should be returned. In an API response, the nextPageToken and prevPageToken properties identify other pages that could be retrieved. /// /// Note: This parameter is supported for use in conjunction with the myRating parameter, but it is not supported for use in conjunction with the id parameter. - pub fn page_token(mut self, new_value: &str) -> VideoListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> VideoListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -9651,7 +9647,7 @@ impl<'a, C, NC, A> VideoListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> VideoListCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> VideoListCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -9659,7 +9655,7 @@ impl<'a, C, NC, A> VideoListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Set this parameter's value to like or dislike to instruct the API to only return videos liked or disliked by the authenticated user. - pub fn my_rating(mut self, new_value: &str) -> VideoListCall<'a, C, NC, A> { + pub fn my_rating(mut self, new_value: &str) -> VideoListCall<'a, C, A> { self._my_rating = Some(new_value.to_string()); self } @@ -9669,7 +9665,7 @@ impl<'a, C, NC, A> VideoListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// The maxResults parameter specifies the maximum number of items that should be returned in the result set. /// /// Note: This parameter is supported for use in conjunction with the myRating parameter, but it is not supported for use in conjunction with the id parameter. - pub fn max_results(mut self, new_value: u32) -> VideoListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> VideoListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -9677,7 +9673,7 @@ impl<'a, C, NC, A> VideoListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// DEPRECATED - pub fn locale(mut self, new_value: &str) -> VideoListCall<'a, C, NC, A> { + pub fn locale(mut self, new_value: &str) -> VideoListCall<'a, C, A> { self._locale = Some(new_value.to_string()); self } @@ -9685,7 +9681,7 @@ impl<'a, C, NC, A> VideoListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The id parameter specifies a comma-separated list of the YouTube video ID(s) for the resource(s) that are being retrieved. In a video resource, the id property specifies the video's ID. - pub fn id(mut self, new_value: &str) -> VideoListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> VideoListCall<'a, C, A> { self._id = Some(new_value.to_string()); self } @@ -9693,7 +9689,7 @@ impl<'a, C, NC, A> VideoListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The hl parameter instructs the API to return a localized version of the video details. If localized text is nor available for the requested language, the localizations object in the API response will contain the requested information in the default language instead. The parameter value is a BCP-47 language code. Your application can determine whether the requested localization was returned by checking the value of the snippet.localized.language property in the API response. - pub fn hl(mut self, new_value: &str) -> VideoListCall<'a, C, NC, A> { + pub fn hl(mut self, new_value: &str) -> VideoListCall<'a, C, A> { self._hl = Some(new_value.to_string()); self } @@ -9701,7 +9697,7 @@ impl<'a, C, NC, A> VideoListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The chart parameter identifies the chart that you want to retrieve. - pub fn chart(mut self, new_value: &str) -> VideoListCall<'a, C, NC, A> { + pub fn chart(mut self, new_value: &str) -> VideoListCall<'a, C, A> { self._chart = Some(new_value.to_string()); self } @@ -9712,7 +9708,7 @@ impl<'a, C, NC, A> VideoListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VideoListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VideoListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9733,7 +9729,7 @@ impl<'a, C, NC, A> VideoListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VideoListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VideoListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9750,7 +9746,7 @@ impl<'a, C, NC, A> VideoListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VideoListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VideoListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -9789,10 +9785,10 @@ impl<'a, C, NC, A> VideoListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct VideoRateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VideoRateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _id: String, _rating: String, _on_behalf_of_content_owner: Option, @@ -9801,9 +9797,9 @@ pub struct VideoRateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VideoRateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VideoRateCall<'a, C, A> {} -impl<'a, C, NC, A> VideoRateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VideoRateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -9904,7 +9900,7 @@ impl<'a, C, NC, A> VideoRateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// The id parameter specifies the YouTube video ID of the video that is being rated or having its rating removed. - pub fn id(mut self, new_value: &str) -> VideoRateCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> VideoRateCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -9914,7 +9910,7 @@ impl<'a, C, NC, A> VideoRateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// we provide this method for API completeness. /// /// Specifies the rating to record. - pub fn rating(mut self, new_value: &str) -> VideoRateCall<'a, C, NC, A> { + pub fn rating(mut self, new_value: &str) -> VideoRateCall<'a, C, A> { self._rating = new_value.to_string(); self } @@ -9924,7 +9920,7 @@ impl<'a, C, NC, A> VideoRateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> VideoRateCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> VideoRateCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -9935,7 +9931,7 @@ impl<'a, C, NC, A> VideoRateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VideoRateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VideoRateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -9956,7 +9952,7 @@ impl<'a, C, NC, A> VideoRateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VideoRateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VideoRateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -9973,7 +9969,7 @@ impl<'a, C, NC, A> VideoRateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VideoRateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VideoRateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10012,10 +10008,10 @@ impl<'a, C, NC, A> VideoRateCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct VideoGetRatingCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VideoGetRatingCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _id: String, _on_behalf_of_content_owner: Option, _delegate: Option<&'a mut Delegate>, @@ -10023,9 +10019,9 @@ pub struct VideoGetRatingCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VideoGetRatingCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VideoGetRatingCall<'a, C, A> {} -impl<'a, C, NC, A> VideoGetRatingCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VideoGetRatingCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10136,7 +10132,7 @@ impl<'a, C, NC, A> VideoGetRatingCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The id parameter specifies a comma-separated list of the YouTube video ID(s) for the resource(s) for which you are retrieving rating data. In a video resource, the id property specifies the video's ID. - pub fn id(mut self, new_value: &str) -> VideoGetRatingCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> VideoGetRatingCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -10146,7 +10142,7 @@ impl<'a, C, NC, A> VideoGetRatingCall<'a, C, NC, A> where NC: hyper::net::Networ /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> VideoGetRatingCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> VideoGetRatingCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -10157,7 +10153,7 @@ impl<'a, C, NC, A> VideoGetRatingCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VideoGetRatingCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VideoGetRatingCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10178,7 +10174,7 @@ impl<'a, C, NC, A> VideoGetRatingCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VideoGetRatingCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VideoGetRatingCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10195,7 +10191,7 @@ impl<'a, C, NC, A> VideoGetRatingCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VideoGetRatingCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VideoGetRatingCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10234,10 +10230,10 @@ impl<'a, C, NC, A> VideoGetRatingCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct VideoDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VideoDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _id: String, _on_behalf_of_content_owner: Option, _delegate: Option<&'a mut Delegate>, @@ -10245,9 +10241,9 @@ pub struct VideoDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VideoDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VideoDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> VideoDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VideoDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10347,7 +10343,7 @@ impl<'a, C, NC, A> VideoDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The id parameter specifies the YouTube video ID for the resource that is being deleted. In a video resource, the id property specifies the video's ID. - pub fn id(mut self, new_value: &str) -> VideoDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> VideoDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -10357,7 +10353,7 @@ impl<'a, C, NC, A> VideoDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The actual CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> VideoDeleteCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> VideoDeleteCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -10368,7 +10364,7 @@ impl<'a, C, NC, A> VideoDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VideoDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VideoDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10389,7 +10385,7 @@ impl<'a, C, NC, A> VideoDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VideoDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VideoDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10406,7 +10402,7 @@ impl<'a, C, NC, A> VideoDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VideoDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VideoDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10486,10 +10482,10 @@ impl<'a, C, NC, A> VideoDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct VideoUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VideoUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _request: Video, _part: String, _on_behalf_of_content_owner: Option, @@ -10498,9 +10494,9 @@ pub struct VideoUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VideoUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VideoUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> VideoUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VideoUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -10636,7 +10632,7 @@ impl<'a, C, NC, A> VideoUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *suggestions* /// * *topicDetails* /// - pub fn request(mut self, new_value: &Video) -> VideoUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Video) -> VideoUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -10670,7 +10666,7 @@ impl<'a, C, NC, A> VideoUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Note that this method will override the existing values for all of the mutable properties that are contained in any parts that the parameter value specifies. For example, a video's privacy setting is contained in the status part. As such, if your request is updating a private video, and the request's part parameter value includes the status part, the video's privacy setting will be updated to whatever value the request body specifies. If the request body does not specify a value, the existing privacy setting will be removed and the video will revert to the default privacy setting. /// /// In addition, not all of those parts contain properties that can be set when setting or updating a video's metadata. For example, the statistics object encapsulates statistics that YouTube calculates for a video and does not contain values that you can set or modify. If the parameter value specifies a part that does not contain mutable values, that part will still be included in the API response. - pub fn part(mut self, new_value: &str) -> VideoUpdateCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> VideoUpdateCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -10680,7 +10676,7 @@ impl<'a, C, NC, A> VideoUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The actual CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> VideoUpdateCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> VideoUpdateCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -10691,7 +10687,7 @@ impl<'a, C, NC, A> VideoUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VideoUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VideoUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -10712,7 +10708,7 @@ impl<'a, C, NC, A> VideoUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VideoUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VideoUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -10729,7 +10725,7 @@ impl<'a, C, NC, A> VideoUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VideoUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VideoUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -10815,10 +10811,10 @@ impl<'a, C, NC, A> VideoUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .upload_resumable(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct VideoInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VideoInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _request: Video, _part: String, _stabilize: Option, @@ -10831,9 +10827,9 @@ pub struct VideoInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VideoInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VideoInsertCall<'a, C, A> {} -impl<'a, C, NC, A> VideoInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VideoInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11095,7 +11091,7 @@ impl<'a, C, NC, A> VideoInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *suggestions* /// * *topicDetails* /// - pub fn request(mut self, new_value: &Video) -> VideoInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Video) -> VideoInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -11125,7 +11121,7 @@ impl<'a, C, NC, A> VideoInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// The part parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include. /// /// The part names that you can include in the parameter value are snippet, contentDetails, fileDetails, liveStreamingDetails, localizations, player, processingDetails, recordingDetails, statistics, status, suggestions, and topicDetails. However, not all of those parts contain properties that can be set when setting or updating a video's metadata. For example, the statistics object encapsulates statistics that YouTube calculates for a video and does not contain values that you can set or modify. If the parameter value specifies a part that does not contain mutable values, that part will still be included in the API response. - pub fn part(mut self, new_value: &str) -> VideoInsertCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> VideoInsertCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -11133,7 +11129,7 @@ impl<'a, C, NC, A> VideoInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The stabilize parameter indicates whether YouTube should adjust the video to remove shaky camera motions. - pub fn stabilize(mut self, new_value: bool) -> VideoInsertCall<'a, C, NC, A> { + pub fn stabilize(mut self, new_value: bool) -> VideoInsertCall<'a, C, A> { self._stabilize = Some(new_value); self } @@ -11145,7 +11141,7 @@ impl<'a, C, NC, A> VideoInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. /// /// This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel. - pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> VideoInsertCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> VideoInsertCall<'a, C, A> { self._on_behalf_of_content_owner_channel = Some(new_value.to_string()); self } @@ -11155,7 +11151,7 @@ impl<'a, C, NC, A> VideoInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> VideoInsertCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> VideoInsertCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -11163,7 +11159,7 @@ impl<'a, C, NC, A> VideoInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The notifySubscribers parameter indicates whether YouTube should send notification to subscribers about the inserted video. - pub fn notify_subscribers(mut self, new_value: bool) -> VideoInsertCall<'a, C, NC, A> { + pub fn notify_subscribers(mut self, new_value: bool) -> VideoInsertCall<'a, C, A> { self._notify_subscribers = Some(new_value); self } @@ -11171,7 +11167,7 @@ impl<'a, C, NC, A> VideoInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The autoLevels parameter indicates whether YouTube should automatically enhance the video's lighting and color. - pub fn auto_levels(mut self, new_value: bool) -> VideoInsertCall<'a, C, NC, A> { + pub fn auto_levels(mut self, new_value: bool) -> VideoInsertCall<'a, C, A> { self._auto_levels = Some(new_value); self } @@ -11182,7 +11178,7 @@ impl<'a, C, NC, A> VideoInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VideoInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VideoInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11203,7 +11199,7 @@ impl<'a, C, NC, A> VideoInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VideoInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VideoInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11220,7 +11216,7 @@ impl<'a, C, NC, A> VideoInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VideoInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VideoInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11279,10 +11275,10 @@ impl<'a, C, NC, A> VideoInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct SubscriptionInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubscriptionInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _request: Subscription, _part: String, _delegate: Option<&'a mut Delegate>, @@ -11290,9 +11286,9 @@ pub struct SubscriptionInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SubscriptionInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SubscriptionInsertCall<'a, C, A> {} -impl<'a, C, NC, A> SubscriptionInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SubscriptionInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11415,7 +11411,7 @@ impl<'a, C, NC, A> SubscriptionInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *snippet* /// * *contentDetails* /// - pub fn request(mut self, new_value: &Subscription) -> SubscriptionInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Subscription) -> SubscriptionInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -11435,7 +11431,7 @@ impl<'a, C, NC, A> SubscriptionInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// The part parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include. /// /// The part names that you can include in the parameter value are snippet and contentDetails. - pub fn part(mut self, new_value: &str) -> SubscriptionInsertCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> SubscriptionInsertCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -11446,7 +11442,7 @@ impl<'a, C, NC, A> SubscriptionInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11467,7 +11463,7 @@ impl<'a, C, NC, A> SubscriptionInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SubscriptionInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SubscriptionInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11484,7 +11480,7 @@ impl<'a, C, NC, A> SubscriptionInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SubscriptionInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SubscriptionInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11547,10 +11543,10 @@ impl<'a, C, NC, A> SubscriptionInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct SubscriptionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubscriptionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _part: String, _page_token: Option, _order: Option, @@ -11567,9 +11563,9 @@ pub struct SubscriptionListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SubscriptionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SubscriptionListCall<'a, C, A> {} -impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SubscriptionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11715,7 +11711,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// The part parameter specifies a comma-separated list of one or more subscription resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, and contentDetails. /// /// If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a subscription resource, the snippet property contains other properties, such as a display title for the subscription. If you set part=snippet, the API response will also contain all of those nested properties. - pub fn part(mut self, new_value: &str) -> SubscriptionListCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> SubscriptionListCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -11723,7 +11719,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The pageToken parameter identifies a specific page in the result set that should be returned. In an API response, the nextPageToken and prevPageToken properties identify other pages that could be retrieved. - pub fn page_token(mut self, new_value: &str) -> SubscriptionListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> SubscriptionListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -11731,7 +11727,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The order parameter specifies the method that will be used to sort resources in the API response. - pub fn order(mut self, new_value: &str) -> SubscriptionListCall<'a, C, NC, A> { + pub fn order(mut self, new_value: &str) -> SubscriptionListCall<'a, C, A> { self._order = Some(new_value.to_string()); self } @@ -11743,7 +11739,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. /// /// This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel. - pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> SubscriptionListCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> SubscriptionListCall<'a, C, A> { self._on_behalf_of_content_owner_channel = Some(new_value.to_string()); self } @@ -11753,7 +11749,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> SubscriptionListCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> SubscriptionListCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -11761,7 +11757,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Set this parameter's value to true to retrieve a feed of the subscribers of the authenticated user. - pub fn my_subscribers(mut self, new_value: bool) -> SubscriptionListCall<'a, C, NC, A> { + pub fn my_subscribers(mut self, new_value: bool) -> SubscriptionListCall<'a, C, A> { self._my_subscribers = Some(new_value); self } @@ -11769,7 +11765,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// Set this parameter's value to true to retrieve a feed of the authenticated user's subscriptions. - pub fn mine(mut self, new_value: bool) -> SubscriptionListCall<'a, C, NC, A> { + pub fn mine(mut self, new_value: bool) -> SubscriptionListCall<'a, C, A> { self._mine = Some(new_value); self } @@ -11777,7 +11773,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The maxResults parameter specifies the maximum number of items that should be returned in the result set. - pub fn max_results(mut self, new_value: u32) -> SubscriptionListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> SubscriptionListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -11785,7 +11781,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The id parameter specifies a comma-separated list of the YouTube subscription ID(s) for the resource(s) that are being retrieved. In a subscription resource, the id property specifies the YouTube subscription ID. - pub fn id(mut self, new_value: &str) -> SubscriptionListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> SubscriptionListCall<'a, C, A> { self._id = Some(new_value.to_string()); self } @@ -11793,7 +11789,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The forChannelId parameter specifies a comma-separated list of channel IDs. The API response will then only contain subscriptions matching those channels. - pub fn for_channel_id(mut self, new_value: &str) -> SubscriptionListCall<'a, C, NC, A> { + pub fn for_channel_id(mut self, new_value: &str) -> SubscriptionListCall<'a, C, A> { self._for_channel_id = Some(new_value.to_string()); self } @@ -11801,7 +11797,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The channelId parameter specifies a YouTube channel ID. The API will only return that channel's subscriptions. - pub fn channel_id(mut self, new_value: &str) -> SubscriptionListCall<'a, C, NC, A> { + pub fn channel_id(mut self, new_value: &str) -> SubscriptionListCall<'a, C, A> { self._channel_id = Some(new_value.to_string()); self } @@ -11812,7 +11808,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -11833,7 +11829,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SubscriptionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SubscriptionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -11850,7 +11846,7 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SubscriptionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SubscriptionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -11888,19 +11884,19 @@ impl<'a, C, NC, A> SubscriptionListCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct SubscriptionDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SubscriptionDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SubscriptionDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SubscriptionDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> SubscriptionDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SubscriptionDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -11997,7 +11993,7 @@ impl<'a, C, NC, A> SubscriptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The id parameter specifies the YouTube subscription ID for the resource that is being deleted. In a subscription resource, the id property specifies the YouTube subscription ID. - pub fn id(mut self, new_value: &str) -> SubscriptionDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> SubscriptionDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -12008,7 +12004,7 @@ impl<'a, C, NC, A> SubscriptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SubscriptionDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12029,7 +12025,7 @@ impl<'a, C, NC, A> SubscriptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SubscriptionDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SubscriptionDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12046,7 +12042,7 @@ impl<'a, C, NC, A> SubscriptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SubscriptionDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SubscriptionDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12128,10 +12124,10 @@ impl<'a, C, NC, A> SubscriptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct SearchListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct SearchListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _part: String, _video_type: Option, _video_syndicated: Option, @@ -12168,9 +12164,9 @@ pub struct SearchListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for SearchListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for SearchListCall<'a, C, A> {} -impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> SearchListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12375,7 +12371,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// The part parameter specifies a comma-separated list of one or more search resource properties that the API response will include. The part names that you can include in the parameter value are id and snippet. /// /// If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a search result, the snippet property contains other properties that identify the result's title, description, and so forth. If you set part=snippet, the API response will also contain all of those nested properties. - pub fn part(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -12383,7 +12379,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The videoType parameter lets you restrict a search to a particular type of videos. - pub fn video_type(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn video_type(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._video_type = Some(new_value.to_string()); self } @@ -12391,7 +12387,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The videoSyndicated parameter lets you to restrict a search to only videos that can be played outside youtube.com. - pub fn video_syndicated(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn video_syndicated(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._video_syndicated = Some(new_value.to_string()); self } @@ -12399,7 +12395,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The videoLicense parameter filters search results to only include videos with a particular license. YouTube lets video uploaders choose to attach either the Creative Commons license or the standard YouTube license to each of their videos. - pub fn video_license(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn video_license(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._video_license = Some(new_value.to_string()); self } @@ -12407,7 +12403,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The videoEmbeddable parameter lets you to restrict a search to only videos that can be embedded into a webpage. - pub fn video_embeddable(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn video_embeddable(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._video_embeddable = Some(new_value.to_string()); self } @@ -12415,7 +12411,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The videoDuration parameter filters video search results based on their duration. - pub fn video_duration(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn video_duration(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._video_duration = Some(new_value.to_string()); self } @@ -12423,7 +12419,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The videoDimension parameter lets you restrict a search to only retrieve 2D or 3D videos. - pub fn video_dimension(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn video_dimension(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._video_dimension = Some(new_value.to_string()); self } @@ -12431,7 +12427,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The videoDefinition parameter lets you restrict a search to only include either high definition (HD) or standard definition (SD) videos. HD videos are available for playback in at least 720p, though higher resolutions, like 1080p, might also be available. - pub fn video_definition(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn video_definition(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._video_definition = Some(new_value.to_string()); self } @@ -12439,7 +12435,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The videoCategoryId parameter filters video search results based on their category. - pub fn video_category_id(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn video_category_id(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._video_category_id = Some(new_value.to_string()); self } @@ -12447,7 +12443,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The videoCaption parameter indicates whether the API should filter video search results based on whether they have captions. - pub fn video_caption(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn video_caption(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._video_caption = Some(new_value.to_string()); self } @@ -12455,7 +12451,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The type parameter restricts a search query to only retrieve a particular type of resource. The value is a comma-separated list of resource types. - pub fn type_(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn type_(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._type_ = Some(new_value.to_string()); self } @@ -12463,7 +12459,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The topicId parameter indicates that the API response should only contain resources associated with the specified topic. The value identifies a Freebase topic ID. - pub fn topic_id(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn topic_id(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._topic_id = Some(new_value.to_string()); self } @@ -12471,7 +12467,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The safeSearch parameter indicates whether the search results should include restricted content as well as standard content. - pub fn safe_search(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn safe_search(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._safe_search = Some(new_value.to_string()); self } @@ -12479,7 +12475,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The relevanceLanguage parameter instructs the API to return search results that are most relevant to the specified language. The parameter value is typically an ISO 639-1 two-letter language code. However, you should use the values zh-Hans for simplified Chinese and zh-Hant for traditional Chinese. Please note that results in other languages will still be returned if they are highly relevant to the search query term. - pub fn relevance_language(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn relevance_language(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._relevance_language = Some(new_value.to_string()); self } @@ -12487,7 +12483,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The relatedToVideoId parameter retrieves a list of videos that are related to the video that the parameter value identifies. The parameter value must be set to a YouTube video ID and, if you are using this parameter, the type parameter must be set to video. - pub fn related_to_video_id(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn related_to_video_id(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._related_to_video_id = Some(new_value.to_string()); self } @@ -12495,7 +12491,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The regionCode parameter instructs the API to return search results for the specified country. The parameter value is an ISO 3166-1 alpha-2 country code. - pub fn region_code(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn region_code(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._region_code = Some(new_value.to_string()); self } @@ -12503,7 +12499,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The q parameter specifies the query term to search for. - pub fn q(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn q(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._q = Some(new_value.to_string()); self } @@ -12511,7 +12507,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The publishedBefore parameter indicates that the API response should only contain resources created before the specified time. The value is an RFC 3339 formatted date-time value (1970-01-01T00:00:00Z). - pub fn published_before(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn published_before(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._published_before = Some(new_value.to_string()); self } @@ -12519,7 +12515,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The publishedAfter parameter indicates that the API response should only contain resources created after the specified time. The value is an RFC 3339 formatted date-time value (1970-01-01T00:00:00Z). - pub fn published_after(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn published_after(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._published_after = Some(new_value.to_string()); self } @@ -12527,7 +12523,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The pageToken parameter identifies a specific page in the result set that should be returned. In an API response, the nextPageToken and prevPageToken properties identify other pages that could be retrieved. - pub fn page_token(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -12535,7 +12531,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The order parameter specifies the method that will be used to order resources in the API response. - pub fn order(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn order(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._order = Some(new_value.to_string()); self } @@ -12545,7 +12541,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -12553,7 +12549,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The maxResults parameter specifies the maximum number of items that should be returned in the result set. - pub fn max_results(mut self, new_value: u32) -> SearchListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> SearchListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -12561,7 +12557,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The locationRadius, in conjunction with the location parameter, defines a geographic area. If the geographic coordinates associated with a video fall within that area, then the video may be included in search results. This parameter value must be a floating point number followed by a measurement unit. Valid measurement units are m, km, ft, and mi. For example, valid parameter values include 1500m, 5km, 10000ft, and 0.75mi. The API does not support locationRadius parameter values larger than 1000 kilometers. - pub fn location_radius(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn location_radius(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._location_radius = Some(new_value.to_string()); self } @@ -12569,7 +12565,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The location parameter restricts a search to videos that have a geographical location specified in their metadata. The value is a string that specifies geographic latitude/longitude coordinates e.g. (37.42307,-122.08427) - pub fn location(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn location(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._location = Some(new_value.to_string()); self } @@ -12577,7 +12573,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The forMine parameter restricts the search to only retrieve videos owned by the authenticated user. If you set this parameter to true, then the type parameter's value must also be set to video. - pub fn for_mine(mut self, new_value: bool) -> SearchListCall<'a, C, NC, A> { + pub fn for_mine(mut self, new_value: bool) -> SearchListCall<'a, C, A> { self._for_mine = Some(new_value); self } @@ -12585,7 +12581,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The forDeveloper parameter restricts the search to only retrieve videos uploaded via the developer's application or website. The API server uses the request's authorization credentials to identify the developer. Therefore, a developer can restrict results to videos uploaded through the developer's own app or website but not to videos uploaded through other apps or sites. - pub fn for_developer(mut self, new_value: bool) -> SearchListCall<'a, C, NC, A> { + pub fn for_developer(mut self, new_value: bool) -> SearchListCall<'a, C, A> { self._for_developer = Some(new_value); self } @@ -12595,7 +12591,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The forContentOwner parameter restricts the search to only retrieve resources owned by the content owner specified by the onBehalfOfContentOwner parameter. The user must be authenticated using a CMS account linked to the specified content owner and onBehalfOfContentOwner must be provided. - pub fn for_content_owner(mut self, new_value: bool) -> SearchListCall<'a, C, NC, A> { + pub fn for_content_owner(mut self, new_value: bool) -> SearchListCall<'a, C, A> { self._for_content_owner = Some(new_value); self } @@ -12603,7 +12599,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The eventType parameter restricts a search to broadcast events. - pub fn event_type(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn event_type(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._event_type = Some(new_value.to_string()); self } @@ -12611,7 +12607,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The channelType parameter lets you restrict a search to a particular type of channel. - pub fn channel_type(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn channel_type(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._channel_type = Some(new_value.to_string()); self } @@ -12619,7 +12615,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// /// /// The channelId parameter indicates that the API response should only contain resources created by the channel - pub fn channel_id(mut self, new_value: &str) -> SearchListCall<'a, C, NC, A> { + pub fn channel_id(mut self, new_value: &str) -> SearchListCall<'a, C, A> { self._channel_id = Some(new_value.to_string()); self } @@ -12630,7 +12626,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> SearchListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> SearchListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12651,7 +12647,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> SearchListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> SearchListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12668,7 +12664,7 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> SearchListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> SearchListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12721,10 +12717,10 @@ impl<'a, C, NC, A> SearchListCall<'a, C, NC, A> where NC: hyper::net::NetworkCon /// .doit(); /// # } /// ``` -pub struct I18nRegionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct I18nRegionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _part: String, _hl: Option, _delegate: Option<&'a mut Delegate>, @@ -12732,9 +12728,9 @@ pub struct I18nRegionListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for I18nRegionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for I18nRegionListCall<'a, C, A> {} -impl<'a, C, NC, A> I18nRegionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> I18nRegionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -12850,7 +12846,7 @@ impl<'a, C, NC, A> I18nRegionListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *snippet* /// /// The part parameter specifies a comma-separated list of one or more i18nRegion resource properties that the API response will include. The part names that you can include in the parameter value are id and snippet. - pub fn part(mut self, new_value: &str) -> I18nRegionListCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> I18nRegionListCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -12858,7 +12854,7 @@ impl<'a, C, NC, A> I18nRegionListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The hl parameter specifies the language that should be used for text values in the API response. - pub fn hl(mut self, new_value: &str) -> I18nRegionListCall<'a, C, NC, A> { + pub fn hl(mut self, new_value: &str) -> I18nRegionListCall<'a, C, A> { self._hl = Some(new_value.to_string()); self } @@ -12869,7 +12865,7 @@ impl<'a, C, NC, A> I18nRegionListCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> I18nRegionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> I18nRegionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -12890,7 +12886,7 @@ impl<'a, C, NC, A> I18nRegionListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> I18nRegionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> I18nRegionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -12907,7 +12903,7 @@ impl<'a, C, NC, A> I18nRegionListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> I18nRegionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> I18nRegionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -12971,10 +12967,10 @@ impl<'a, C, NC, A> I18nRegionListCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct LiveStreamUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LiveStreamUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _request: LiveStream, _part: String, _on_behalf_of_content_owner_channel: Option, @@ -12984,9 +12980,9 @@ pub struct LiveStreamUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LiveStreamUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LiveStreamUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> LiveStreamUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LiveStreamUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13117,7 +13113,7 @@ impl<'a, C, NC, A> LiveStreamUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *cdn* /// * *status* /// - pub fn request(mut self, new_value: &LiveStream) -> LiveStreamUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &LiveStream) -> LiveStreamUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13141,7 +13137,7 @@ impl<'a, C, NC, A> LiveStreamUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// The part properties that you can include in the parameter value are id, snippet, cdn, and status. /// /// Note that this method will override the existing values for all of the mutable properties that are contained in any parts that the parameter value specifies. If the request body does not specify a value for a mutable property, the existing value for that property will be removed. - pub fn part(mut self, new_value: &str) -> LiveStreamUpdateCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> LiveStreamUpdateCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -13153,7 +13149,7 @@ impl<'a, C, NC, A> LiveStreamUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. /// /// This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel. - pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> LiveStreamUpdateCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> LiveStreamUpdateCall<'a, C, A> { self._on_behalf_of_content_owner_channel = Some(new_value.to_string()); self } @@ -13163,7 +13159,7 @@ impl<'a, C, NC, A> LiveStreamUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> LiveStreamUpdateCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> LiveStreamUpdateCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -13174,7 +13170,7 @@ impl<'a, C, NC, A> LiveStreamUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LiveStreamUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LiveStreamUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13195,7 +13191,7 @@ impl<'a, C, NC, A> LiveStreamUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LiveStreamUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LiveStreamUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13212,7 +13208,7 @@ impl<'a, C, NC, A> LiveStreamUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LiveStreamUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LiveStreamUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13252,10 +13248,10 @@ impl<'a, C, NC, A> LiveStreamUpdateCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct LiveStreamDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LiveStreamDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _id: String, _on_behalf_of_content_owner_channel: Option, _on_behalf_of_content_owner: Option, @@ -13264,9 +13260,9 @@ pub struct LiveStreamDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LiveStreamDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LiveStreamDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> LiveStreamDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LiveStreamDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13369,7 +13365,7 @@ impl<'a, C, NC, A> LiveStreamDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// we provide this method for API completeness. /// /// The id parameter specifies the YouTube live stream ID for the resource that is being deleted. - pub fn id(mut self, new_value: &str) -> LiveStreamDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> LiveStreamDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -13381,7 +13377,7 @@ impl<'a, C, NC, A> LiveStreamDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. /// /// This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel. - pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> LiveStreamDeleteCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> LiveStreamDeleteCall<'a, C, A> { self._on_behalf_of_content_owner_channel = Some(new_value.to_string()); self } @@ -13391,7 +13387,7 @@ impl<'a, C, NC, A> LiveStreamDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> LiveStreamDeleteCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> LiveStreamDeleteCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -13402,7 +13398,7 @@ impl<'a, C, NC, A> LiveStreamDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LiveStreamDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LiveStreamDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13423,7 +13419,7 @@ impl<'a, C, NC, A> LiveStreamDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LiveStreamDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LiveStreamDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13440,7 +13436,7 @@ impl<'a, C, NC, A> LiveStreamDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LiveStreamDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LiveStreamDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13499,10 +13495,10 @@ impl<'a, C, NC, A> LiveStreamDeleteCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct LiveStreamListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LiveStreamListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _part: String, _page_token: Option, _on_behalf_of_content_owner_channel: Option, @@ -13515,9 +13511,9 @@ pub struct LiveStreamListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LiveStreamListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LiveStreamListCall<'a, C, A> {} -impl<'a, C, NC, A> LiveStreamListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LiveStreamListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13650,7 +13646,7 @@ impl<'a, C, NC, A> LiveStreamListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *status* /// /// The part parameter specifies a comma-separated list of one or more liveStream resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, cdn, and status. - pub fn part(mut self, new_value: &str) -> LiveStreamListCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> LiveStreamListCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -13658,7 +13654,7 @@ impl<'a, C, NC, A> LiveStreamListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The pageToken parameter identifies a specific page in the result set that should be returned. In an API response, the nextPageToken and prevPageToken properties identify other pages that could be retrieved. - pub fn page_token(mut self, new_value: &str) -> LiveStreamListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> LiveStreamListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -13670,7 +13666,7 @@ impl<'a, C, NC, A> LiveStreamListCall<'a, C, NC, A> where NC: hyper::net::Networ /// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. /// /// This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel. - pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> LiveStreamListCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> LiveStreamListCall<'a, C, A> { self._on_behalf_of_content_owner_channel = Some(new_value.to_string()); self } @@ -13680,7 +13676,7 @@ impl<'a, C, NC, A> LiveStreamListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> LiveStreamListCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> LiveStreamListCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -13688,7 +13684,7 @@ impl<'a, C, NC, A> LiveStreamListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The mine parameter can be used to instruct the API to only return streams owned by the authenticated user. Set the parameter value to true to only retrieve your own streams. - pub fn mine(mut self, new_value: bool) -> LiveStreamListCall<'a, C, NC, A> { + pub fn mine(mut self, new_value: bool) -> LiveStreamListCall<'a, C, A> { self._mine = Some(new_value); self } @@ -13696,7 +13692,7 @@ impl<'a, C, NC, A> LiveStreamListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The maxResults parameter specifies the maximum number of items that should be returned in the result set. Acceptable values are 0 to 50, inclusive. The default value is 5. - pub fn max_results(mut self, new_value: u32) -> LiveStreamListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> LiveStreamListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -13704,7 +13700,7 @@ impl<'a, C, NC, A> LiveStreamListCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The id parameter specifies a comma-separated list of YouTube stream IDs that identify the streams being retrieved. In a liveStream resource, the id property specifies the stream's ID. - pub fn id(mut self, new_value: &str) -> LiveStreamListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> LiveStreamListCall<'a, C, A> { self._id = Some(new_value.to_string()); self } @@ -13715,7 +13711,7 @@ impl<'a, C, NC, A> LiveStreamListCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LiveStreamListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LiveStreamListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -13736,7 +13732,7 @@ impl<'a, C, NC, A> LiveStreamListCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LiveStreamListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LiveStreamListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -13753,7 +13749,7 @@ impl<'a, C, NC, A> LiveStreamListCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LiveStreamListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LiveStreamListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -13817,10 +13813,10 @@ impl<'a, C, NC, A> LiveStreamListCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct LiveStreamInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LiveStreamInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _request: LiveStream, _part: String, _on_behalf_of_content_owner_channel: Option, @@ -13830,9 +13826,9 @@ pub struct LiveStreamInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LiveStreamInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LiveStreamInsertCall<'a, C, A> {} -impl<'a, C, NC, A> LiveStreamInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LiveStreamInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -13963,7 +13959,7 @@ impl<'a, C, NC, A> LiveStreamInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *cdn* /// * *status* /// - pub fn request(mut self, new_value: &LiveStream) -> LiveStreamInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &LiveStream) -> LiveStreamInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -13985,7 +13981,7 @@ impl<'a, C, NC, A> LiveStreamInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// The part parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include. /// /// The part properties that you can include in the parameter value are id, snippet, cdn, and status. - pub fn part(mut self, new_value: &str) -> LiveStreamInsertCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> LiveStreamInsertCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -13997,7 +13993,7 @@ impl<'a, C, NC, A> LiveStreamInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. /// /// This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel. - pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> LiveStreamInsertCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> LiveStreamInsertCall<'a, C, A> { self._on_behalf_of_content_owner_channel = Some(new_value.to_string()); self } @@ -14007,7 +14003,7 @@ impl<'a, C, NC, A> LiveStreamInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> LiveStreamInsertCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> LiveStreamInsertCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -14018,7 +14014,7 @@ impl<'a, C, NC, A> LiveStreamInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LiveStreamInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LiveStreamInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14039,7 +14035,7 @@ impl<'a, C, NC, A> LiveStreamInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LiveStreamInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LiveStreamInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14056,7 +14052,7 @@ impl<'a, C, NC, A> LiveStreamInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LiveStreamInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LiveStreamInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14116,10 +14112,10 @@ impl<'a, C, NC, A> LiveStreamInsertCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct ChannelUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChannelUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _request: Channel, _part: String, _on_behalf_of_content_owner: Option, @@ -14128,9 +14124,9 @@ pub struct ChannelUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChannelUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChannelUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> ChannelUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChannelUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14256,7 +14252,7 @@ impl<'a, C, NC, A> ChannelUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// * *id* /// * *invideoPromotion* /// - pub fn request(mut self, new_value: &Channel) -> ChannelUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Channel) -> ChannelUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -14278,7 +14274,7 @@ impl<'a, C, NC, A> ChannelUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// The part names that you can include in the parameter value are id and invideoPromotion. /// /// Note that this method will override the existing values for all of the mutable properties that are contained in any parts that the parameter value specifies. - pub fn part(mut self, new_value: &str) -> ChannelUpdateCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> ChannelUpdateCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -14286,7 +14282,7 @@ impl<'a, C, NC, A> ChannelUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// The onBehalfOfContentOwner parameter indicates that the authenticated user is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The actual CMS account that the user authenticates with needs to be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> ChannelUpdateCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> ChannelUpdateCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -14297,7 +14293,7 @@ impl<'a, C, NC, A> ChannelUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14318,7 +14314,7 @@ impl<'a, C, NC, A> ChannelUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChannelUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChannelUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14335,7 +14331,7 @@ impl<'a, C, NC, A> ChannelUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChannelUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChannelUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14402,10 +14398,10 @@ impl<'a, C, NC, A> ChannelUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct ChannelListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ChannelListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _part: String, _page_token: Option, _on_behalf_of_content_owner: Option, @@ -14422,9 +14418,9 @@ pub struct ChannelListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ChannelListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ChannelListCall<'a, C, A> {} -impl<'a, C, NC, A> ChannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ChannelListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14573,7 +14569,7 @@ impl<'a, C, NC, A> ChannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// The part parameter specifies a comma-separated list of one or more channel resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, contentDetails, statistics, topicDetails, and invideoPromotion. /// /// If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a channel resource, the contentDetails property contains other properties, such as the uploads properties. As such, if you set part=contentDetails, the API response will also contain all of those nested properties. - pub fn part(mut self, new_value: &str) -> ChannelListCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> ChannelListCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -14581,7 +14577,7 @@ impl<'a, C, NC, A> ChannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The pageToken parameter identifies a specific page in the result set that should be returned. In an API response, the nextPageToken and prevPageToken properties identify other pages that could be retrieved. - pub fn page_token(mut self, new_value: &str) -> ChannelListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ChannelListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -14589,7 +14585,7 @@ impl<'a, C, NC, A> ChannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The onBehalfOfContentOwner parameter indicates that the authenticated user is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The actual CMS account that the user authenticates with needs to be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> ChannelListCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> ChannelListCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -14597,7 +14593,7 @@ impl<'a, C, NC, A> ChannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Set this parameter's value to true to retrieve a list of channels that subscribed to the authenticated user's channel. - pub fn my_subscribers(mut self, new_value: bool) -> ChannelListCall<'a, C, NC, A> { + pub fn my_subscribers(mut self, new_value: bool) -> ChannelListCall<'a, C, A> { self._my_subscribers = Some(new_value); self } @@ -14605,7 +14601,7 @@ impl<'a, C, NC, A> ChannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Set this parameter's value to true to instruct the API to only return channels owned by the authenticated user. - pub fn mine(mut self, new_value: bool) -> ChannelListCall<'a, C, NC, A> { + pub fn mine(mut self, new_value: bool) -> ChannelListCall<'a, C, A> { self._mine = Some(new_value); self } @@ -14613,7 +14609,7 @@ impl<'a, C, NC, A> ChannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The maxResults parameter specifies the maximum number of items that should be returned in the result set. - pub fn max_results(mut self, new_value: u32) -> ChannelListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> ChannelListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -14621,7 +14617,7 @@ impl<'a, C, NC, A> ChannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// Set this parameter's value to true to instruct the API to only return channels managed by the content owner that the onBehalfOfContentOwner parameter specifies. The user must be authenticated as a CMS account linked to the specified content owner and onBehalfOfContentOwner must be provided. - pub fn managed_by_me(mut self, new_value: bool) -> ChannelListCall<'a, C, NC, A> { + pub fn managed_by_me(mut self, new_value: bool) -> ChannelListCall<'a, C, A> { self._managed_by_me = Some(new_value); self } @@ -14629,7 +14625,7 @@ impl<'a, C, NC, A> ChannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The id parameter specifies a comma-separated list of the YouTube channel ID(s) for the resource(s) that are being retrieved. In a channel resource, the id property specifies the channel's YouTube channel ID. - pub fn id(mut self, new_value: &str) -> ChannelListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> ChannelListCall<'a, C, A> { self._id = Some(new_value.to_string()); self } @@ -14637,7 +14633,7 @@ impl<'a, C, NC, A> ChannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The hl parameter should be used for filter out the properties that are not in the given language. Used for the brandingSettings part. - pub fn hl(mut self, new_value: &str) -> ChannelListCall<'a, C, NC, A> { + pub fn hl(mut self, new_value: &str) -> ChannelListCall<'a, C, A> { self._hl = Some(new_value.to_string()); self } @@ -14645,7 +14641,7 @@ impl<'a, C, NC, A> ChannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The forUsername parameter specifies a YouTube username, thereby requesting the channel associated with that username. - pub fn for_username(mut self, new_value: &str) -> ChannelListCall<'a, C, NC, A> { + pub fn for_username(mut self, new_value: &str) -> ChannelListCall<'a, C, A> { self._for_username = Some(new_value.to_string()); self } @@ -14653,7 +14649,7 @@ impl<'a, C, NC, A> ChannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The categoryId parameter specifies a YouTube guide category, thereby requesting YouTube channels associated with that category. - pub fn category_id(mut self, new_value: &str) -> ChannelListCall<'a, C, NC, A> { + pub fn category_id(mut self, new_value: &str) -> ChannelListCall<'a, C, A> { self._category_id = Some(new_value.to_string()); self } @@ -14664,7 +14660,7 @@ impl<'a, C, NC, A> ChannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ChannelListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14685,7 +14681,7 @@ impl<'a, C, NC, A> ChannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ChannelListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ChannelListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14702,7 +14698,7 @@ impl<'a, C, NC, A> ChannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ChannelListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ChannelListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -14764,10 +14760,10 @@ impl<'a, C, NC, A> ChannelListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct PlaylistItemInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlaylistItemInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _request: PlaylistItem, _part: String, _on_behalf_of_content_owner: Option, @@ -14776,9 +14772,9 @@ pub struct PlaylistItemInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlaylistItemInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlaylistItemInsertCall<'a, C, A> {} -impl<'a, C, NC, A> PlaylistItemInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlaylistItemInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -14905,7 +14901,7 @@ impl<'a, C, NC, A> PlaylistItemInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *contentDetails* /// * *status* /// - pub fn request(mut self, new_value: &PlaylistItem) -> PlaylistItemInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PlaylistItem) -> PlaylistItemInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -14926,7 +14922,7 @@ impl<'a, C, NC, A> PlaylistItemInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// The part parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include. /// /// The part names that you can include in the parameter value are snippet, contentDetails, and status. - pub fn part(mut self, new_value: &str) -> PlaylistItemInsertCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> PlaylistItemInsertCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -14936,7 +14932,7 @@ impl<'a, C, NC, A> PlaylistItemInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> PlaylistItemInsertCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> PlaylistItemInsertCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -14947,7 +14943,7 @@ impl<'a, C, NC, A> PlaylistItemInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlaylistItemInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlaylistItemInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -14968,7 +14964,7 @@ impl<'a, C, NC, A> PlaylistItemInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlaylistItemInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlaylistItemInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -14985,7 +14981,7 @@ impl<'a, C, NC, A> PlaylistItemInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlaylistItemInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlaylistItemInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15023,19 +15019,19 @@ impl<'a, C, NC, A> PlaylistItemInsertCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct PlaylistItemDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlaylistItemDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _id: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlaylistItemDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlaylistItemDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> PlaylistItemDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlaylistItemDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15132,7 +15128,7 @@ impl<'a, C, NC, A> PlaylistItemDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// we provide this method for API completeness. /// /// The id parameter specifies the YouTube playlist item ID for the playlist item that is being deleted. In a playlistItem resource, the id property specifies the playlist item's ID. - pub fn id(mut self, new_value: &str) -> PlaylistItemDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> PlaylistItemDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -15143,7 +15139,7 @@ impl<'a, C, NC, A> PlaylistItemDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlaylistItemDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlaylistItemDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15164,7 +15160,7 @@ impl<'a, C, NC, A> PlaylistItemDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlaylistItemDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlaylistItemDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15181,7 +15177,7 @@ impl<'a, C, NC, A> PlaylistItemDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlaylistItemDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlaylistItemDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15241,10 +15237,10 @@ impl<'a, C, NC, A> PlaylistItemDeleteCall<'a, C, NC, A> where NC: hyper::net::Ne /// .doit(); /// # } /// ``` -pub struct PlaylistItemListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlaylistItemListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _part: String, _video_id: Option, _playlist_id: Option, @@ -15257,9 +15253,9 @@ pub struct PlaylistItemListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlaylistItemListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlaylistItemListCall<'a, C, A> {} -impl<'a, C, NC, A> PlaylistItemListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlaylistItemListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15394,7 +15390,7 @@ impl<'a, C, NC, A> PlaylistItemListCall<'a, C, NC, A> where NC: hyper::net::Netw /// The part parameter specifies a comma-separated list of one or more playlistItem resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, contentDetails, and status. /// /// If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a playlistItem resource, the snippet property contains numerous fields, including the title, description, position, and resourceId properties. As such, if you set part=snippet, the API response will contain all of those properties. - pub fn part(mut self, new_value: &str) -> PlaylistItemListCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> PlaylistItemListCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -15402,7 +15398,7 @@ impl<'a, C, NC, A> PlaylistItemListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The videoId parameter specifies that the request should return only the playlist items that contain the specified video. - pub fn video_id(mut self, new_value: &str) -> PlaylistItemListCall<'a, C, NC, A> { + pub fn video_id(mut self, new_value: &str) -> PlaylistItemListCall<'a, C, A> { self._video_id = Some(new_value.to_string()); self } @@ -15410,7 +15406,7 @@ impl<'a, C, NC, A> PlaylistItemListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The playlistId parameter specifies the unique ID of the playlist for which you want to retrieve playlist items. Note that even though this is an optional parameter, every request to retrieve playlist items must specify a value for either the id parameter or the playlistId parameter. - pub fn playlist_id(mut self, new_value: &str) -> PlaylistItemListCall<'a, C, NC, A> { + pub fn playlist_id(mut self, new_value: &str) -> PlaylistItemListCall<'a, C, A> { self._playlist_id = Some(new_value.to_string()); self } @@ -15418,7 +15414,7 @@ impl<'a, C, NC, A> PlaylistItemListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The pageToken parameter identifies a specific page in the result set that should be returned. In an API response, the nextPageToken and prevPageToken properties identify other pages that could be retrieved. - pub fn page_token(mut self, new_value: &str) -> PlaylistItemListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> PlaylistItemListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -15428,7 +15424,7 @@ impl<'a, C, NC, A> PlaylistItemListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> PlaylistItemListCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> PlaylistItemListCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -15436,7 +15432,7 @@ impl<'a, C, NC, A> PlaylistItemListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The maxResults parameter specifies the maximum number of items that should be returned in the result set. - pub fn max_results(mut self, new_value: u32) -> PlaylistItemListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> PlaylistItemListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -15444,7 +15440,7 @@ impl<'a, C, NC, A> PlaylistItemListCall<'a, C, NC, A> where NC: hyper::net::Netw /// /// /// The id parameter specifies a comma-separated list of one or more unique playlist item IDs. - pub fn id(mut self, new_value: &str) -> PlaylistItemListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> PlaylistItemListCall<'a, C, A> { self._id = Some(new_value.to_string()); self } @@ -15455,7 +15451,7 @@ impl<'a, C, NC, A> PlaylistItemListCall<'a, C, NC, A> where NC: hyper::net::Netw /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlaylistItemListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlaylistItemListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15476,7 +15472,7 @@ impl<'a, C, NC, A> PlaylistItemListCall<'a, C, NC, A> where NC: hyper::net::Netw /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlaylistItemListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlaylistItemListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15493,7 +15489,7 @@ impl<'a, C, NC, A> PlaylistItemListCall<'a, C, NC, A> where NC: hyper::net::Netw /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlaylistItemListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlaylistItemListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15554,10 +15550,10 @@ impl<'a, C, NC, A> PlaylistItemListCall<'a, C, NC, A> where NC: hyper::net::Netw /// .doit(); /// # } /// ``` -pub struct PlaylistItemUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct PlaylistItemUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _request: PlaylistItem, _part: String, _delegate: Option<&'a mut Delegate>, @@ -15565,9 +15561,9 @@ pub struct PlaylistItemUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for PlaylistItemUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for PlaylistItemUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> PlaylistItemUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> PlaylistItemUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -15691,7 +15687,7 @@ impl<'a, C, NC, A> PlaylistItemUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *contentDetails* /// * *status* /// - pub fn request(mut self, new_value: &PlaylistItem) -> PlaylistItemUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &PlaylistItem) -> PlaylistItemUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -15714,7 +15710,7 @@ impl<'a, C, NC, A> PlaylistItemUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// The part names that you can include in the parameter value are snippet, contentDetails, and status. /// /// Note that this method will override the existing values for all of the mutable properties that are contained in any parts that the parameter value specifies. For example, a playlist item can specify a start time and end time, which identify the times portion of the video that should play when users watch the video in the playlist. If your request is updating a playlist item that sets these values, and the request's part parameter value includes the contentDetails part, the playlist item's start and end times will be updated to whatever value the request body specifies. If the request body does not specify values, the existing start and end times will be removed and replaced with the default settings. - pub fn part(mut self, new_value: &str) -> PlaylistItemUpdateCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> PlaylistItemUpdateCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -15725,7 +15721,7 @@ impl<'a, C, NC, A> PlaylistItemUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlaylistItemUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> PlaylistItemUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -15746,7 +15742,7 @@ impl<'a, C, NC, A> PlaylistItemUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> PlaylistItemUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> PlaylistItemUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -15763,7 +15759,7 @@ impl<'a, C, NC, A> PlaylistItemUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> PlaylistItemUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> PlaylistItemUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -15809,10 +15805,10 @@ impl<'a, C, NC, A> PlaylistItemUpdateCall<'a, C, NC, A> where NC: hyper::net::Ne /// .upload(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct WatermarkSetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct WatermarkSetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _request: InvideoBranding, _channel_id: String, _on_behalf_of_content_owner: Option, @@ -15821,9 +15817,9 @@ pub struct WatermarkSetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for WatermarkSetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for WatermarkSetCall<'a, C, A> {} -impl<'a, C, NC, A> WatermarkSetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> WatermarkSetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16044,7 +16040,7 @@ impl<'a, C, NC, A> WatermarkSetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &InvideoBranding) -> WatermarkSetCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &InvideoBranding) -> WatermarkSetCall<'a, C, A> { self._request = new_value.clone(); self } @@ -16054,7 +16050,7 @@ impl<'a, C, NC, A> WatermarkSetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// we provide this method for API completeness. /// /// The channelId parameter specifies a YouTube channel ID for which the watermark is being provided. - pub fn channel_id(mut self, new_value: &str) -> WatermarkSetCall<'a, C, NC, A> { + pub fn channel_id(mut self, new_value: &str) -> WatermarkSetCall<'a, C, A> { self._channel_id = new_value.to_string(); self } @@ -16062,7 +16058,7 @@ impl<'a, C, NC, A> WatermarkSetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The onBehalfOfContentOwner parameter indicates that the authenticated user is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The actual CMS account that the user authenticates with needs to be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> WatermarkSetCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> WatermarkSetCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -16073,7 +16069,7 @@ impl<'a, C, NC, A> WatermarkSetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> WatermarkSetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> WatermarkSetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16094,7 +16090,7 @@ impl<'a, C, NC, A> WatermarkSetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> WatermarkSetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> WatermarkSetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16111,7 +16107,7 @@ impl<'a, C, NC, A> WatermarkSetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> WatermarkSetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> WatermarkSetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16150,10 +16146,10 @@ impl<'a, C, NC, A> WatermarkSetCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct WatermarkUnsetCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct WatermarkUnsetCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _channel_id: String, _on_behalf_of_content_owner: Option, _delegate: Option<&'a mut Delegate>, @@ -16161,9 +16157,9 @@ pub struct WatermarkUnsetCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for WatermarkUnsetCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for WatermarkUnsetCall<'a, C, A> {} -impl<'a, C, NC, A> WatermarkUnsetCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> WatermarkUnsetCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16263,7 +16259,7 @@ impl<'a, C, NC, A> WatermarkUnsetCall<'a, C, NC, A> where NC: hyper::net::Networ /// we provide this method for API completeness. /// /// The channelId parameter specifies a YouTube channel ID for which the watermark is being unset. - pub fn channel_id(mut self, new_value: &str) -> WatermarkUnsetCall<'a, C, NC, A> { + pub fn channel_id(mut self, new_value: &str) -> WatermarkUnsetCall<'a, C, A> { self._channel_id = new_value.to_string(); self } @@ -16271,7 +16267,7 @@ impl<'a, C, NC, A> WatermarkUnsetCall<'a, C, NC, A> where NC: hyper::net::Networ /// /// /// The onBehalfOfContentOwner parameter indicates that the authenticated user is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The actual CMS account that the user authenticates with needs to be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> WatermarkUnsetCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> WatermarkUnsetCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -16282,7 +16278,7 @@ impl<'a, C, NC, A> WatermarkUnsetCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> WatermarkUnsetCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> WatermarkUnsetCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16303,7 +16299,7 @@ impl<'a, C, NC, A> WatermarkUnsetCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> WatermarkUnsetCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> WatermarkUnsetCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16320,7 +16316,7 @@ impl<'a, C, NC, A> WatermarkUnsetCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> WatermarkUnsetCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> WatermarkUnsetCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16377,10 +16373,10 @@ impl<'a, C, NC, A> WatermarkUnsetCall<'a, C, NC, A> where NC: hyper::net::Networ /// .doit(); /// # } /// ``` -pub struct LiveBroadcastControlCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LiveBroadcastControlCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _id: String, _part: String, _walltime: Option, @@ -16393,9 +16389,9 @@ pub struct LiveBroadcastControlCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LiveBroadcastControlCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LiveBroadcastControlCall<'a, C, A> {} -impl<'a, C, NC, A> LiveBroadcastControlCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LiveBroadcastControlCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16519,7 +16515,7 @@ impl<'a, C, NC, A> LiveBroadcastControlCall<'a, C, NC, A> where NC: hyper::net:: /// we provide this method for API completeness. /// /// The id parameter specifies the YouTube live broadcast ID that uniquely identifies the broadcast in which the slate is being updated. - pub fn id(mut self, new_value: &str) -> LiveBroadcastControlCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> LiveBroadcastControlCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -16536,7 +16532,7 @@ impl<'a, C, NC, A> LiveBroadcastControlCall<'a, C, NC, A> where NC: hyper::net:: /// * *status* /// /// The part parameter specifies a comma-separated list of one or more liveBroadcast resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, contentDetails, and status. - pub fn part(mut self, new_value: &str) -> LiveBroadcastControlCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> LiveBroadcastControlCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -16544,7 +16540,7 @@ impl<'a, C, NC, A> LiveBroadcastControlCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// The walltime parameter specifies the wall clock time at which the specified slate change will occur. The value is specified in ISO 8601 (YYYY-MM-DDThh:mm:ss.sssZ) format. - pub fn walltime(mut self, new_value: &str) -> LiveBroadcastControlCall<'a, C, NC, A> { + pub fn walltime(mut self, new_value: &str) -> LiveBroadcastControlCall<'a, C, A> { self._walltime = Some(new_value.to_string()); self } @@ -16556,7 +16552,7 @@ impl<'a, C, NC, A> LiveBroadcastControlCall<'a, C, NC, A> where NC: hyper::net:: /// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. /// /// This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel. - pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> LiveBroadcastControlCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> LiveBroadcastControlCall<'a, C, A> { self._on_behalf_of_content_owner_channel = Some(new_value.to_string()); self } @@ -16566,7 +16562,7 @@ impl<'a, C, NC, A> LiveBroadcastControlCall<'a, C, NC, A> where NC: hyper::net:: /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> LiveBroadcastControlCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> LiveBroadcastControlCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -16578,7 +16574,7 @@ impl<'a, C, NC, A> LiveBroadcastControlCall<'a, C, NC, A> where NC: hyper::net:: /// If you do not specify a value for this parameter, then YouTube performs the action as soon as possible. See the Getting started guide for more details. /// /// Important: You should only specify a value for this parameter if your broadcast stream is delayed. - pub fn offset_time_ms(mut self, new_value: &str) -> LiveBroadcastControlCall<'a, C, NC, A> { + pub fn offset_time_ms(mut self, new_value: &str) -> LiveBroadcastControlCall<'a, C, A> { self._offset_time_ms = Some(new_value.to_string()); self } @@ -16586,7 +16582,7 @@ impl<'a, C, NC, A> LiveBroadcastControlCall<'a, C, NC, A> where NC: hyper::net:: /// /// /// The displaySlate parameter specifies whether the slate is being enabled or disabled. - pub fn display_slate(mut self, new_value: bool) -> LiveBroadcastControlCall<'a, C, NC, A> { + pub fn display_slate(mut self, new_value: bool) -> LiveBroadcastControlCall<'a, C, A> { self._display_slate = Some(new_value); self } @@ -16597,7 +16593,7 @@ impl<'a, C, NC, A> LiveBroadcastControlCall<'a, C, NC, A> where NC: hyper::net:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LiveBroadcastControlCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LiveBroadcastControlCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16618,7 +16614,7 @@ impl<'a, C, NC, A> LiveBroadcastControlCall<'a, C, NC, A> where NC: hyper::net:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LiveBroadcastControlCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LiveBroadcastControlCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16635,7 +16631,7 @@ impl<'a, C, NC, A> LiveBroadcastControlCall<'a, C, NC, A> where NC: hyper::net:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LiveBroadcastControlCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LiveBroadcastControlCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -16699,10 +16695,10 @@ impl<'a, C, NC, A> LiveBroadcastControlCall<'a, C, NC, A> where NC: hyper::net:: /// .doit(); /// # } /// ``` -pub struct LiveBroadcastUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LiveBroadcastUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _request: LiveBroadcast, _part: String, _on_behalf_of_content_owner_channel: Option, @@ -16712,9 +16708,9 @@ pub struct LiveBroadcastUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LiveBroadcastUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LiveBroadcastUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> LiveBroadcastUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LiveBroadcastUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -16845,7 +16841,7 @@ impl<'a, C, NC, A> LiveBroadcastUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// * *contentDetails* /// * *status* /// - pub fn request(mut self, new_value: &LiveBroadcast) -> LiveBroadcastUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &LiveBroadcast) -> LiveBroadcastUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -16869,7 +16865,7 @@ impl<'a, C, NC, A> LiveBroadcastUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// The part properties that you can include in the parameter value are id, snippet, contentDetails, and status. /// /// Note that this method will override the existing values for all of the mutable properties that are contained in any parts that the parameter value specifies. For example, a broadcast's privacy status is defined in the status part. As such, if your request is updating a private or unlisted broadcast, and the request's part parameter value includes the status part, the broadcast's privacy setting will be updated to whatever value the request body specifies. If the request body does not specify a value, the existing privacy setting will be removed and the broadcast will revert to the default privacy setting. - pub fn part(mut self, new_value: &str) -> LiveBroadcastUpdateCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> LiveBroadcastUpdateCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -16881,7 +16877,7 @@ impl<'a, C, NC, A> LiveBroadcastUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. /// /// This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel. - pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> LiveBroadcastUpdateCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> LiveBroadcastUpdateCall<'a, C, A> { self._on_behalf_of_content_owner_channel = Some(new_value.to_string()); self } @@ -16891,7 +16887,7 @@ impl<'a, C, NC, A> LiveBroadcastUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> LiveBroadcastUpdateCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> LiveBroadcastUpdateCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -16902,7 +16898,7 @@ impl<'a, C, NC, A> LiveBroadcastUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LiveBroadcastUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LiveBroadcastUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -16923,7 +16919,7 @@ impl<'a, C, NC, A> LiveBroadcastUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LiveBroadcastUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LiveBroadcastUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -16940,7 +16936,7 @@ impl<'a, C, NC, A> LiveBroadcastUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LiveBroadcastUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LiveBroadcastUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17004,10 +17000,10 @@ impl<'a, C, NC, A> LiveBroadcastUpdateCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct LiveBroadcastInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LiveBroadcastInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _request: LiveBroadcast, _part: String, _on_behalf_of_content_owner_channel: Option, @@ -17017,9 +17013,9 @@ pub struct LiveBroadcastInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LiveBroadcastInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LiveBroadcastInsertCall<'a, C, A> {} -impl<'a, C, NC, A> LiveBroadcastInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LiveBroadcastInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17150,7 +17146,7 @@ impl<'a, C, NC, A> LiveBroadcastInsertCall<'a, C, NC, A> where NC: hyper::net::N /// * *contentDetails* /// * *status* /// - pub fn request(mut self, new_value: &LiveBroadcast) -> LiveBroadcastInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &LiveBroadcast) -> LiveBroadcastInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -17172,7 +17168,7 @@ impl<'a, C, NC, A> LiveBroadcastInsertCall<'a, C, NC, A> where NC: hyper::net::N /// The part parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include. /// /// The part properties that you can include in the parameter value are id, snippet, contentDetails, and status. - pub fn part(mut self, new_value: &str) -> LiveBroadcastInsertCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> LiveBroadcastInsertCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -17184,7 +17180,7 @@ impl<'a, C, NC, A> LiveBroadcastInsertCall<'a, C, NC, A> where NC: hyper::net::N /// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. /// /// This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel. - pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> LiveBroadcastInsertCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> LiveBroadcastInsertCall<'a, C, A> { self._on_behalf_of_content_owner_channel = Some(new_value.to_string()); self } @@ -17194,7 +17190,7 @@ impl<'a, C, NC, A> LiveBroadcastInsertCall<'a, C, NC, A> where NC: hyper::net::N /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> LiveBroadcastInsertCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> LiveBroadcastInsertCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -17205,7 +17201,7 @@ impl<'a, C, NC, A> LiveBroadcastInsertCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LiveBroadcastInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LiveBroadcastInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17226,7 +17222,7 @@ impl<'a, C, NC, A> LiveBroadcastInsertCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LiveBroadcastInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LiveBroadcastInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17243,7 +17239,7 @@ impl<'a, C, NC, A> LiveBroadcastInsertCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LiveBroadcastInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LiveBroadcastInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17298,10 +17294,10 @@ impl<'a, C, NC, A> LiveBroadcastInsertCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct LiveBroadcastBindCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LiveBroadcastBindCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _id: String, _part: String, _stream_id: Option, @@ -17312,9 +17308,9 @@ pub struct LiveBroadcastBindCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LiveBroadcastBindCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LiveBroadcastBindCall<'a, C, A> {} -impl<'a, C, NC, A> LiveBroadcastBindCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LiveBroadcastBindCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17432,7 +17428,7 @@ impl<'a, C, NC, A> LiveBroadcastBindCall<'a, C, NC, A> where NC: hyper::net::Net /// we provide this method for API completeness. /// /// The id parameter specifies the unique ID of the broadcast that is being bound to a video stream. - pub fn id(mut self, new_value: &str) -> LiveBroadcastBindCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> LiveBroadcastBindCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -17449,7 +17445,7 @@ impl<'a, C, NC, A> LiveBroadcastBindCall<'a, C, NC, A> where NC: hyper::net::Net /// * *status* /// /// The part parameter specifies a comma-separated list of one or more liveBroadcast resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, contentDetails, and status. - pub fn part(mut self, new_value: &str) -> LiveBroadcastBindCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> LiveBroadcastBindCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -17457,7 +17453,7 @@ impl<'a, C, NC, A> LiveBroadcastBindCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The streamId parameter specifies the unique ID of the video stream that is being bound to a broadcast. If this parameter is omitted, the API will remove any existing binding between the broadcast and a video stream. - pub fn stream_id(mut self, new_value: &str) -> LiveBroadcastBindCall<'a, C, NC, A> { + pub fn stream_id(mut self, new_value: &str) -> LiveBroadcastBindCall<'a, C, A> { self._stream_id = Some(new_value.to_string()); self } @@ -17469,7 +17465,7 @@ impl<'a, C, NC, A> LiveBroadcastBindCall<'a, C, NC, A> where NC: hyper::net::Net /// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. /// /// This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel. - pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> LiveBroadcastBindCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> LiveBroadcastBindCall<'a, C, A> { self._on_behalf_of_content_owner_channel = Some(new_value.to_string()); self } @@ -17479,7 +17475,7 @@ impl<'a, C, NC, A> LiveBroadcastBindCall<'a, C, NC, A> where NC: hyper::net::Net /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> LiveBroadcastBindCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> LiveBroadcastBindCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -17490,7 +17486,7 @@ impl<'a, C, NC, A> LiveBroadcastBindCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LiveBroadcastBindCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LiveBroadcastBindCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17511,7 +17507,7 @@ impl<'a, C, NC, A> LiveBroadcastBindCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LiveBroadcastBindCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LiveBroadcastBindCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17528,7 +17524,7 @@ impl<'a, C, NC, A> LiveBroadcastBindCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LiveBroadcastBindCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LiveBroadcastBindCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17588,10 +17584,10 @@ impl<'a, C, NC, A> LiveBroadcastBindCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct LiveBroadcastListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LiveBroadcastListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _part: String, _page_token: Option, _on_behalf_of_content_owner_channel: Option, @@ -17605,9 +17601,9 @@ pub struct LiveBroadcastListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LiveBroadcastListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LiveBroadcastListCall<'a, C, A> {} -impl<'a, C, NC, A> LiveBroadcastListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LiveBroadcastListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -17743,7 +17739,7 @@ impl<'a, C, NC, A> LiveBroadcastListCall<'a, C, NC, A> where NC: hyper::net::Net /// * *status* /// /// The part parameter specifies a comma-separated list of one or more liveBroadcast resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, contentDetails, and status. - pub fn part(mut self, new_value: &str) -> LiveBroadcastListCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> LiveBroadcastListCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -17751,7 +17747,7 @@ impl<'a, C, NC, A> LiveBroadcastListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The pageToken parameter identifies a specific page in the result set that should be returned. In an API response, the nextPageToken and prevPageToken properties identify other pages that could be retrieved. - pub fn page_token(mut self, new_value: &str) -> LiveBroadcastListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> LiveBroadcastListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -17763,7 +17759,7 @@ impl<'a, C, NC, A> LiveBroadcastListCall<'a, C, NC, A> where NC: hyper::net::Net /// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. /// /// This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel. - pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> LiveBroadcastListCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> LiveBroadcastListCall<'a, C, A> { self._on_behalf_of_content_owner_channel = Some(new_value.to_string()); self } @@ -17773,7 +17769,7 @@ impl<'a, C, NC, A> LiveBroadcastListCall<'a, C, NC, A> where NC: hyper::net::Net /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> LiveBroadcastListCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> LiveBroadcastListCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -17781,7 +17777,7 @@ impl<'a, C, NC, A> LiveBroadcastListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The mine parameter can be used to instruct the API to only return broadcasts owned by the authenticated user. Set the parameter value to true to only retrieve your own broadcasts. - pub fn mine(mut self, new_value: bool) -> LiveBroadcastListCall<'a, C, NC, A> { + pub fn mine(mut self, new_value: bool) -> LiveBroadcastListCall<'a, C, A> { self._mine = Some(new_value); self } @@ -17789,7 +17785,7 @@ impl<'a, C, NC, A> LiveBroadcastListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The maxResults parameter specifies the maximum number of items that should be returned in the result set. - pub fn max_results(mut self, new_value: u32) -> LiveBroadcastListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> LiveBroadcastListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -17797,7 +17793,7 @@ impl<'a, C, NC, A> LiveBroadcastListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The id parameter specifies a comma-separated list of YouTube broadcast IDs that identify the broadcasts being retrieved. In a liveBroadcast resource, the id property specifies the broadcast's ID. - pub fn id(mut self, new_value: &str) -> LiveBroadcastListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> LiveBroadcastListCall<'a, C, A> { self._id = Some(new_value.to_string()); self } @@ -17805,7 +17801,7 @@ impl<'a, C, NC, A> LiveBroadcastListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The broadcastStatus parameter filters the API response to only include broadcasts with the specified status. - pub fn broadcast_status(mut self, new_value: &str) -> LiveBroadcastListCall<'a, C, NC, A> { + pub fn broadcast_status(mut self, new_value: &str) -> LiveBroadcastListCall<'a, C, A> { self._broadcast_status = Some(new_value.to_string()); self } @@ -17816,7 +17812,7 @@ impl<'a, C, NC, A> LiveBroadcastListCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LiveBroadcastListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LiveBroadcastListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -17837,7 +17833,7 @@ impl<'a, C, NC, A> LiveBroadcastListCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LiveBroadcastListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LiveBroadcastListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -17854,7 +17850,7 @@ impl<'a, C, NC, A> LiveBroadcastListCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LiveBroadcastListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LiveBroadcastListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -17894,10 +17890,10 @@ impl<'a, C, NC, A> LiveBroadcastListCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct LiveBroadcastDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LiveBroadcastDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _id: String, _on_behalf_of_content_owner_channel: Option, _on_behalf_of_content_owner: Option, @@ -17906,9 +17902,9 @@ pub struct LiveBroadcastDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LiveBroadcastDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LiveBroadcastDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> LiveBroadcastDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LiveBroadcastDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18011,7 +18007,7 @@ impl<'a, C, NC, A> LiveBroadcastDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// we provide this method for API completeness. /// /// The id parameter specifies the YouTube live broadcast ID for the resource that is being deleted. - pub fn id(mut self, new_value: &str) -> LiveBroadcastDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> LiveBroadcastDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -18023,7 +18019,7 @@ impl<'a, C, NC, A> LiveBroadcastDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. /// /// This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel. - pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> LiveBroadcastDeleteCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> LiveBroadcastDeleteCall<'a, C, A> { self._on_behalf_of_content_owner_channel = Some(new_value.to_string()); self } @@ -18033,7 +18029,7 @@ impl<'a, C, NC, A> LiveBroadcastDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> LiveBroadcastDeleteCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> LiveBroadcastDeleteCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -18044,7 +18040,7 @@ impl<'a, C, NC, A> LiveBroadcastDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LiveBroadcastDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LiveBroadcastDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18065,7 +18061,7 @@ impl<'a, C, NC, A> LiveBroadcastDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LiveBroadcastDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LiveBroadcastDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18082,7 +18078,7 @@ impl<'a, C, NC, A> LiveBroadcastDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LiveBroadcastDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LiveBroadcastDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18136,10 +18132,10 @@ impl<'a, C, NC, A> LiveBroadcastDeleteCall<'a, C, NC, A> where NC: hyper::net::N /// .doit(); /// # } /// ``` -pub struct LiveBroadcastTransitionCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct LiveBroadcastTransitionCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _broadcast_status: String, _id: String, _part: String, @@ -18150,9 +18146,9 @@ pub struct LiveBroadcastTransitionCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for LiveBroadcastTransitionCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for LiveBroadcastTransitionCall<'a, C, A> {} -impl<'a, C, NC, A> LiveBroadcastTransitionCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> LiveBroadcastTransitionCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18268,7 +18264,7 @@ impl<'a, C, NC, A> LiveBroadcastTransitionCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The broadcastStatus parameter identifies the state to which the broadcast is changing. Note that to transition a broadcast to either the testing or live state, the status.streamStatus must be active for the stream that the broadcast is bound to. - pub fn broadcast_status(mut self, new_value: &str) -> LiveBroadcastTransitionCall<'a, C, NC, A> { + pub fn broadcast_status(mut self, new_value: &str) -> LiveBroadcastTransitionCall<'a, C, A> { self._broadcast_status = new_value.to_string(); self } @@ -18278,7 +18274,7 @@ impl<'a, C, NC, A> LiveBroadcastTransitionCall<'a, C, NC, A> where NC: hyper::ne /// we provide this method for API completeness. /// /// The id parameter specifies the unique ID of the broadcast that is transitioning to another status. - pub fn id(mut self, new_value: &str) -> LiveBroadcastTransitionCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> LiveBroadcastTransitionCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -18295,7 +18291,7 @@ impl<'a, C, NC, A> LiveBroadcastTransitionCall<'a, C, NC, A> where NC: hyper::ne /// * *status* /// /// The part parameter specifies a comma-separated list of one or more liveBroadcast resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, contentDetails, and status. - pub fn part(mut self, new_value: &str) -> LiveBroadcastTransitionCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> LiveBroadcastTransitionCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -18307,7 +18303,7 @@ impl<'a, C, NC, A> LiveBroadcastTransitionCall<'a, C, NC, A> where NC: hyper::ne /// The onBehalfOfContentOwnerChannel parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. /// /// This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel. - pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> LiveBroadcastTransitionCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner_channel(mut self, new_value: &str) -> LiveBroadcastTransitionCall<'a, C, A> { self._on_behalf_of_content_owner_channel = Some(new_value.to_string()); self } @@ -18317,7 +18313,7 @@ impl<'a, C, NC, A> LiveBroadcastTransitionCall<'a, C, NC, A> where NC: hyper::ne /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> LiveBroadcastTransitionCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> LiveBroadcastTransitionCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -18328,7 +18324,7 @@ impl<'a, C, NC, A> LiveBroadcastTransitionCall<'a, C, NC, A> where NC: hyper::ne /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> LiveBroadcastTransitionCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> LiveBroadcastTransitionCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18349,7 +18345,7 @@ impl<'a, C, NC, A> LiveBroadcastTransitionCall<'a, C, NC, A> where NC: hyper::ne /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> LiveBroadcastTransitionCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> LiveBroadcastTransitionCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18366,7 +18362,7 @@ impl<'a, C, NC, A> LiveBroadcastTransitionCall<'a, C, NC, A> where NC: hyper::ne /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> LiveBroadcastTransitionCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> LiveBroadcastTransitionCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18406,10 +18402,10 @@ impl<'a, C, NC, A> LiveBroadcastTransitionCall<'a, C, NC, A> where NC: hyper::ne /// .doit(); /// # } /// ``` -pub struct CaptionDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CaptionDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _id: String, _on_behalf_of: Option, _debug_project_id_override: Option, @@ -18418,9 +18414,9 @@ pub struct CaptionDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CaptionDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CaptionDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> CaptionDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CaptionDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18523,7 +18519,7 @@ impl<'a, C, NC, A> CaptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The id parameter identifies the caption track that is being deleted. The value is a caption track ID as identified by the id property in a caption resource. - pub fn id(mut self, new_value: &str) -> CaptionDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> CaptionDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -18531,7 +18527,7 @@ impl<'a, C, NC, A> CaptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// ID of the Google+ Page for the channel that the request is be on behalf of - pub fn on_behalf_of(mut self, new_value: &str) -> CaptionDeleteCall<'a, C, NC, A> { + pub fn on_behalf_of(mut self, new_value: &str) -> CaptionDeleteCall<'a, C, A> { self._on_behalf_of = Some(new_value.to_string()); self } @@ -18539,7 +18535,7 @@ impl<'a, C, NC, A> CaptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// The debugProjectIdOverride parameter should be used for mimicking a request for a certain project ID - pub fn debug_project_id_override(mut self, new_value: &str) -> CaptionDeleteCall<'a, C, NC, A> { + pub fn debug_project_id_override(mut self, new_value: &str) -> CaptionDeleteCall<'a, C, A> { self._debug_project_id_override = Some(new_value.to_string()); self } @@ -18550,7 +18546,7 @@ impl<'a, C, NC, A> CaptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CaptionDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CaptionDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18571,7 +18567,7 @@ impl<'a, C, NC, A> CaptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CaptionDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CaptionDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18588,7 +18584,7 @@ impl<'a, C, NC, A> CaptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CaptionDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CaptionDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -18636,10 +18632,10 @@ impl<'a, C, NC, A> CaptionDeleteCall<'a, C, NC, A> where NC: hyper::net::Network /// .upload_resumable(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct CaptionInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CaptionInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _request: Caption, _part: String, _sync: Option, @@ -18650,9 +18646,9 @@ pub struct CaptionInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CaptionInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CaptionInsertCall<'a, C, A> {} -impl<'a, C, NC, A> CaptionInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CaptionInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -18893,7 +18889,7 @@ impl<'a, C, NC, A> CaptionInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Caption) -> CaptionInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Caption) -> CaptionInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -18906,7 +18902,7 @@ impl<'a, C, NC, A> CaptionInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// the parts you provide in addition to the ones you want in the response. /// /// The part parameter specifies the caption resource parts that the API response will include. Set the parameter value to snippet. - pub fn part(mut self, new_value: &str) -> CaptionInsertCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> CaptionInsertCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -18916,7 +18912,7 @@ impl<'a, C, NC, A> CaptionInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// The sync parameter indicates whether YouTube should automatically synchronize the caption file with the audio track of the video. If you set the value to true, YouTube will disregard any time codes that are in the uploaded caption file and generate new time codes for the captions. /// /// You should set the sync parameter to true if you are uploading a transcript, which has no time codes, or if you suspect the time codes in your file are incorrect and want YouTube to try to fix them. - pub fn sync(mut self, new_value: bool) -> CaptionInsertCall<'a, C, NC, A> { + pub fn sync(mut self, new_value: bool) -> CaptionInsertCall<'a, C, A> { self._sync = Some(new_value); self } @@ -18924,7 +18920,7 @@ impl<'a, C, NC, A> CaptionInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// ID of the Google+ Page for the channel that the request is be on behalf of - pub fn on_behalf_of(mut self, new_value: &str) -> CaptionInsertCall<'a, C, NC, A> { + pub fn on_behalf_of(mut self, new_value: &str) -> CaptionInsertCall<'a, C, A> { self._on_behalf_of = Some(new_value.to_string()); self } @@ -18932,7 +18928,7 @@ impl<'a, C, NC, A> CaptionInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// The debugProjectIdOverride parameter should be used for mimicking a request for a certain project ID. - pub fn debug_project_id_override(mut self, new_value: &str) -> CaptionInsertCall<'a, C, NC, A> { + pub fn debug_project_id_override(mut self, new_value: &str) -> CaptionInsertCall<'a, C, A> { self._debug_project_id_override = Some(new_value.to_string()); self } @@ -18943,7 +18939,7 @@ impl<'a, C, NC, A> CaptionInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CaptionInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CaptionInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -18964,7 +18960,7 @@ impl<'a, C, NC, A> CaptionInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CaptionInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CaptionInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -18981,7 +18977,7 @@ impl<'a, C, NC, A> CaptionInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CaptionInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CaptionInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19022,10 +19018,10 @@ impl<'a, C, NC, A> CaptionInsertCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct CaptionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CaptionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _part: String, _video_id: String, _on_behalf_of: Option, @@ -19036,9 +19032,9 @@ pub struct CaptionListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CaptionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CaptionListCall<'a, C, A> {} -impl<'a, C, NC, A> CaptionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CaptionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19156,7 +19152,7 @@ impl<'a, C, NC, A> CaptionListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The part parameter specifies the caption resource parts that the API response will include. - pub fn part(mut self, new_value: &str) -> CaptionListCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> CaptionListCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -19166,7 +19162,7 @@ impl<'a, C, NC, A> CaptionListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The videoId parameter specifies the YouTube video ID of the video for which the API should return caption tracks. - pub fn video_id(mut self, new_value: &str) -> CaptionListCall<'a, C, NC, A> { + pub fn video_id(mut self, new_value: &str) -> CaptionListCall<'a, C, A> { self._video_id = new_value.to_string(); self } @@ -19174,7 +19170,7 @@ impl<'a, C, NC, A> CaptionListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// ID of the Google+ Page for the channel that the request is on behalf of. - pub fn on_behalf_of(mut self, new_value: &str) -> CaptionListCall<'a, C, NC, A> { + pub fn on_behalf_of(mut self, new_value: &str) -> CaptionListCall<'a, C, A> { self._on_behalf_of = Some(new_value.to_string()); self } @@ -19182,7 +19178,7 @@ impl<'a, C, NC, A> CaptionListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The id parameter specifies a comma-separated list of IDs that identify the caption resources that should be retrieved. Each ID must identify a caption track associated with the specified video. - pub fn id(mut self, new_value: &str) -> CaptionListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> CaptionListCall<'a, C, A> { self._id = Some(new_value.to_string()); self } @@ -19190,7 +19186,7 @@ impl<'a, C, NC, A> CaptionListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The debugProjectIdOverride parameter should be used for mimicking a request for a certain project ID. - pub fn debug_project_id_override(mut self, new_value: &str) -> CaptionListCall<'a, C, NC, A> { + pub fn debug_project_id_override(mut self, new_value: &str) -> CaptionListCall<'a, C, A> { self._debug_project_id_override = Some(new_value.to_string()); self } @@ -19201,7 +19197,7 @@ impl<'a, C, NC, A> CaptionListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CaptionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CaptionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19222,7 +19218,7 @@ impl<'a, C, NC, A> CaptionListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CaptionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CaptionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19239,7 +19235,7 @@ impl<'a, C, NC, A> CaptionListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CaptionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CaptionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19284,10 +19280,10 @@ impl<'a, C, NC, A> CaptionListCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct CaptionDownloadCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CaptionDownloadCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _id: String, _tlang: Option, _tfmt: Option, @@ -19298,9 +19294,9 @@ pub struct CaptionDownloadCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CaptionDownloadCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CaptionDownloadCall<'a, C, A> {} -impl<'a, C, NC, A> CaptionDownloadCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CaptionDownloadCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19433,7 +19429,7 @@ impl<'a, C, NC, A> CaptionDownloadCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The id parameter identifies the caption track that is being retrieved. The value is a caption track ID as identified by the id property in a caption resource. - pub fn id(mut self, new_value: &str) -> CaptionDownloadCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> CaptionDownloadCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -19441,7 +19437,7 @@ impl<'a, C, NC, A> CaptionDownloadCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The tlang parameter specifies that the API response should return a translation of the specified caption track. The parameter value is an ISO 639-1 two-letter language code that identifies the desired caption language. The translation is generated by using machine translation, such as Google Translate. - pub fn tlang(mut self, new_value: &str) -> CaptionDownloadCall<'a, C, NC, A> { + pub fn tlang(mut self, new_value: &str) -> CaptionDownloadCall<'a, C, A> { self._tlang = Some(new_value.to_string()); self } @@ -19449,7 +19445,7 @@ impl<'a, C, NC, A> CaptionDownloadCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The tfmt parameter specifies that the caption track should be returned in a specific format. If the parameter is not included in the request, the track is returned in its original format. - pub fn tfmt(mut self, new_value: &str) -> CaptionDownloadCall<'a, C, NC, A> { + pub fn tfmt(mut self, new_value: &str) -> CaptionDownloadCall<'a, C, A> { self._tfmt = Some(new_value.to_string()); self } @@ -19457,7 +19453,7 @@ impl<'a, C, NC, A> CaptionDownloadCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// ID of the Google+ Page for the channel that the request is be on behalf of - pub fn on_behalf_of(mut self, new_value: &str) -> CaptionDownloadCall<'a, C, NC, A> { + pub fn on_behalf_of(mut self, new_value: &str) -> CaptionDownloadCall<'a, C, A> { self._on_behalf_of = Some(new_value.to_string()); self } @@ -19465,7 +19461,7 @@ impl<'a, C, NC, A> CaptionDownloadCall<'a, C, NC, A> where NC: hyper::net::Netwo /// /// /// The debugProjectIdOverride parameter should be used for mimicking a request for a certain project ID - pub fn debug_project_id_override(mut self, new_value: &str) -> CaptionDownloadCall<'a, C, NC, A> { + pub fn debug_project_id_override(mut self, new_value: &str) -> CaptionDownloadCall<'a, C, A> { self._debug_project_id_override = Some(new_value.to_string()); self } @@ -19476,7 +19472,7 @@ impl<'a, C, NC, A> CaptionDownloadCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CaptionDownloadCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CaptionDownloadCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19497,7 +19493,7 @@ impl<'a, C, NC, A> CaptionDownloadCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CaptionDownloadCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CaptionDownloadCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19514,7 +19510,7 @@ impl<'a, C, NC, A> CaptionDownloadCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CaptionDownloadCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CaptionDownloadCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19562,10 +19558,10 @@ impl<'a, C, NC, A> CaptionDownloadCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .upload_resumable(fs::File::open("file.ext").unwrap(), "application/octet-stream".parse().unwrap()); /// # } /// ``` -pub struct CaptionUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct CaptionUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _request: Caption, _part: String, _sync: Option, @@ -19576,9 +19572,9 @@ pub struct CaptionUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for CaptionUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for CaptionUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> CaptionUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> CaptionUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -19819,7 +19815,7 @@ impl<'a, C, NC, A> CaptionUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Caption) -> CaptionUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Caption) -> CaptionUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -19832,7 +19828,7 @@ impl<'a, C, NC, A> CaptionUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// the parts you provide in addition to the ones you want in the response. /// /// The part parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include. Set the property value to snippet if you are updating the track's draft status. Otherwise, set the property value to id. - pub fn part(mut self, new_value: &str) -> CaptionUpdateCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> CaptionUpdateCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -19842,7 +19838,7 @@ impl<'a, C, NC, A> CaptionUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Note: The API server only processes the parameter value if the request contains an updated caption file. /// /// The sync parameter indicates whether YouTube should automatically synchronize the caption file with the audio track of the video. If you set the value to true, YouTube will automatically synchronize the caption track with the audio track. - pub fn sync(mut self, new_value: bool) -> CaptionUpdateCall<'a, C, NC, A> { + pub fn sync(mut self, new_value: bool) -> CaptionUpdateCall<'a, C, A> { self._sync = Some(new_value); self } @@ -19850,7 +19846,7 @@ impl<'a, C, NC, A> CaptionUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// ID of the Google+ Page for the channel that the request is be on behalf of - pub fn on_behalf_of(mut self, new_value: &str) -> CaptionUpdateCall<'a, C, NC, A> { + pub fn on_behalf_of(mut self, new_value: &str) -> CaptionUpdateCall<'a, C, A> { self._on_behalf_of = Some(new_value.to_string()); self } @@ -19858,7 +19854,7 @@ impl<'a, C, NC, A> CaptionUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// /// /// The debugProjectIdOverride parameter should be used for mimicking a request for a certain project ID. - pub fn debug_project_id_override(mut self, new_value: &str) -> CaptionUpdateCall<'a, C, NC, A> { + pub fn debug_project_id_override(mut self, new_value: &str) -> CaptionUpdateCall<'a, C, A> { self._debug_project_id_override = Some(new_value.to_string()); self } @@ -19869,7 +19865,7 @@ impl<'a, C, NC, A> CaptionUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> CaptionUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> CaptionUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -19890,7 +19886,7 @@ impl<'a, C, NC, A> CaptionUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> CaptionUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> CaptionUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -19907,7 +19903,7 @@ impl<'a, C, NC, A> CaptionUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> CaptionUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> CaptionUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -19962,10 +19958,10 @@ impl<'a, C, NC, A> CaptionUpdateCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct VideoCategoryListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct VideoCategoryListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _part: String, _region_code: Option, _id: Option, @@ -19975,9 +19971,9 @@ pub struct VideoCategoryListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for VideoCategoryListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for VideoCategoryListCall<'a, C, A> {} -impl<'a, C, NC, A> VideoCategoryListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> VideoCategoryListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -20099,7 +20095,7 @@ impl<'a, C, NC, A> VideoCategoryListCall<'a, C, NC, A> where NC: hyper::net::Net /// * *snippet* /// /// The part parameter specifies the videoCategory resource parts that the API response will include. Supported values are id and snippet. - pub fn part(mut self, new_value: &str) -> VideoCategoryListCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> VideoCategoryListCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -20107,7 +20103,7 @@ impl<'a, C, NC, A> VideoCategoryListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The regionCode parameter instructs the API to return the list of video categories available in the specified country. The parameter value is an ISO 3166-1 alpha-2 country code. - pub fn region_code(mut self, new_value: &str) -> VideoCategoryListCall<'a, C, NC, A> { + pub fn region_code(mut self, new_value: &str) -> VideoCategoryListCall<'a, C, A> { self._region_code = Some(new_value.to_string()); self } @@ -20115,7 +20111,7 @@ impl<'a, C, NC, A> VideoCategoryListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The id parameter specifies a comma-separated list of video category IDs for the resources that you are retrieving. - pub fn id(mut self, new_value: &str) -> VideoCategoryListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> VideoCategoryListCall<'a, C, A> { self._id = Some(new_value.to_string()); self } @@ -20123,7 +20119,7 @@ impl<'a, C, NC, A> VideoCategoryListCall<'a, C, NC, A> where NC: hyper::net::Net /// /// /// The hl parameter specifies the language that should be used for text values in the API response. - pub fn hl(mut self, new_value: &str) -> VideoCategoryListCall<'a, C, NC, A> { + pub fn hl(mut self, new_value: &str) -> VideoCategoryListCall<'a, C, A> { self._hl = Some(new_value.to_string()); self } @@ -20134,7 +20130,7 @@ impl<'a, C, NC, A> VideoCategoryListCall<'a, C, NC, A> where NC: hyper::net::Net /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> VideoCategoryListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> VideoCategoryListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -20155,7 +20151,7 @@ impl<'a, C, NC, A> VideoCategoryListCall<'a, C, NC, A> where NC: hyper::net::Net /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> VideoCategoryListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> VideoCategoryListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -20172,7 +20168,7 @@ impl<'a, C, NC, A> VideoCategoryListCall<'a, C, NC, A> where NC: hyper::net::Net /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> VideoCategoryListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> VideoCategoryListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -20232,10 +20228,10 @@ impl<'a, C, NC, A> VideoCategoryListCall<'a, C, NC, A> where NC: hyper::net::Net /// .doit(); /// # } /// ``` -pub struct ActivityListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ActivityListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _part: String, _region_code: Option, _published_before: Option, @@ -20250,9 +20246,9 @@ pub struct ActivityListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ActivityListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ActivityListCall<'a, C, A> {} -impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ActivityListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -20392,7 +20388,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// The part parameter specifies a comma-separated list of one or more activity resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, and contentDetails. /// /// If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a activity resource, the snippet property contains other properties that identify the type of activity, a display title for the activity, and so forth. If you set part=snippet, the API response will also contain all of those nested properties. - pub fn part(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -20400,7 +20396,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The regionCode parameter instructs the API to return results for the specified country. The parameter value is an ISO 3166-1 alpha-2 country code. YouTube uses this value when the authorized user's previous activity on YouTube does not provide enough information to generate the activity feed. - pub fn region_code(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn region_code(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._region_code = Some(new_value.to_string()); self } @@ -20408,7 +20404,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The publishedBefore parameter specifies the date and time before which an activity must have occurred for that activity to be included in the API response. If the parameter value specifies a day, but not a time, then any activities that occurred that day will be excluded from the result set. The value is specified in ISO 8601 (YYYY-MM-DDThh:mm:ss.sZ) format. - pub fn published_before(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn published_before(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._published_before = Some(new_value.to_string()); self } @@ -20416,7 +20412,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The publishedAfter parameter specifies the earliest date and time that an activity could have occurred for that activity to be included in the API response. If the parameter value specifies a day, but not a time, then any activities that occurred that day will be included in the result set. The value is specified in ISO 8601 (YYYY-MM-DDThh:mm:ss.sZ) format. - pub fn published_after(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn published_after(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._published_after = Some(new_value.to_string()); self } @@ -20424,7 +20420,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The pageToken parameter identifies a specific page in the result set that should be returned. In an API response, the nextPageToken and prevPageToken properties identify other pages that could be retrieved. - pub fn page_token(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn page_token(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._page_token = Some(new_value.to_string()); self } @@ -20432,7 +20428,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Set this parameter's value to true to retrieve a feed of the authenticated user's activities. - pub fn mine(mut self, new_value: bool) -> ActivityListCall<'a, C, NC, A> { + pub fn mine(mut self, new_value: bool) -> ActivityListCall<'a, C, A> { self._mine = Some(new_value); self } @@ -20440,7 +20436,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The maxResults parameter specifies the maximum number of items that should be returned in the result set. - pub fn max_results(mut self, new_value: u32) -> ActivityListCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: u32) -> ActivityListCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -20448,7 +20444,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// Set this parameter's value to true to retrieve the activity feed that displays on the YouTube home page for the currently authenticated user. - pub fn home(mut self, new_value: bool) -> ActivityListCall<'a, C, NC, A> { + pub fn home(mut self, new_value: bool) -> ActivityListCall<'a, C, A> { self._home = Some(new_value); self } @@ -20456,7 +20452,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// /// /// The channelId parameter specifies a unique YouTube channel ID. The API will then return a list of that channel's activities. - pub fn channel_id(mut self, new_value: &str) -> ActivityListCall<'a, C, NC, A> { + pub fn channel_id(mut self, new_value: &str) -> ActivityListCall<'a, C, A> { self._channel_id = Some(new_value.to_string()); self } @@ -20467,7 +20463,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivityListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivityListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -20488,7 +20484,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ActivityListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ActivityListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -20505,7 +20501,7 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ActivityListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ActivityListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -20565,10 +20561,10 @@ impl<'a, C, NC, A> ActivityListCall<'a, C, NC, A> where NC: hyper::net::NetworkC /// .doit(); /// # } /// ``` -pub struct ActivityInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ActivityInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTube, + hub: &'a YouTube, _request: Activity, _part: String, _delegate: Option<&'a mut Delegate>, @@ -20576,9 +20572,9 @@ pub struct ActivityInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ActivityInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ActivityInsertCall<'a, C, A> {} -impl<'a, C, NC, A> ActivityInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ActivityInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -20701,7 +20697,7 @@ impl<'a, C, NC, A> ActivityInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *snippet* /// * *contentDetails* /// - pub fn request(mut self, new_value: &Activity) -> ActivityInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Activity) -> ActivityInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -20721,7 +20717,7 @@ impl<'a, C, NC, A> ActivityInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// The part parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include. /// /// The part names that you can include in the parameter value are snippet and contentDetails. - pub fn part(mut self, new_value: &str) -> ActivityInsertCall<'a, C, NC, A> { + pub fn part(mut self, new_value: &str) -> ActivityInsertCall<'a, C, A> { self._part = new_value.to_string(); self } @@ -20732,7 +20728,7 @@ impl<'a, C, NC, A> ActivityInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivityInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ActivityInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -20753,7 +20749,7 @@ impl<'a, C, NC, A> ActivityInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ActivityInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ActivityInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -20770,7 +20766,7 @@ impl<'a, C, NC, A> ActivityInsertCall<'a, C, NC, A> where NC: hyper::net::Networ /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ActivityInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ActivityInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self diff --git a/gen/youtubeanalytics1/Cargo.toml b/gen/youtubeanalytics1/Cargo.toml index 8de0ccac7ce..db1cf535df9 100644 --- a/gen/youtubeanalytics1/Cargo.toml +++ b/gen/youtubeanalytics1/Cargo.toml @@ -4,12 +4,12 @@ [package] name = "google-youtubeanalytics1" -version = "0.1.4+20150304" +version = "0.1.5+20150304" authors = ["Sebastian Thiel "] description = "A complete library to interact with YouTube Analytics (protocol v1)" repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/youtubeanalytics1" homepage = "http://developers.google.com/youtube/analytics/" -documentation = "http://byron.github.io/google-apis-rs/google-youtubeanalytics1" +documentation = "http://byron.github.io/google-apis-rs/google_youtubeanalytics1" license = "MIT" keywords = ["youtubeAnalytics", "google", "protocol", "web", "api"] diff --git a/gen/youtubeanalytics1/README.md b/gen/youtubeanalytics1/README.md index b88a5fb212e..e6904d83f17 100644 --- a/gen/youtubeanalytics1/README.md +++ b/gen/youtubeanalytics1/README.md @@ -5,7 +5,7 @@ DO NOT EDIT ! --> The `google-youtubeanalytics1` library allows access to all features of the *Google YouTube Analytics* service. -This documentation was generated from *YouTube Analytics* crate version *0.1.4+20150304*, where *20150304* is the exact revision of the *youtubeAnalytics:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +This documentation was generated from *YouTube Analytics* crate version *0.1.5+20150304*, where *20150304* is the exact revision of the *youtubeAnalytics:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. Everything else about the *YouTube Analytics* *v1* API can be found at the [official documentation site](http://developers.google.com/youtube/analytics/). diff --git a/gen/youtubeanalytics1/src/cmn.rs b/gen/youtubeanalytics1/src/cmn.rs index b7910987f29..2ff60c3baf0 100644 --- a/gen/youtubeanalytics1/src/cmn.rs +++ b/gen/youtubeanalytics1/src/cmn.rs @@ -483,8 +483,8 @@ impl HeaderFormat for RangeResponseHeader { } /// A utility type to perform a resumable upload from start to end. -pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { - pub client: &'a mut hyper::client::Client, +pub struct ResumableUploadHelper<'a, A: 'a> { + pub client: &'a mut hyper::client::Client, pub delegate: &'a mut Delegate, pub start_at: Option, pub auth: &'a mut A, @@ -496,9 +496,8 @@ pub struct ResumableUploadHelper<'a, NC: 'a, A: 'a> { pub content_length: u64 } -impl<'a, NC, A> ResumableUploadHelper<'a, NC, A> - where NC: hyper::net::NetworkConnector, - A: oauth2::GetToken { +impl<'a, A> ResumableUploadHelper<'a, A> + where A: oauth2::GetToken { fn query_transfer_status(&mut self) -> std::result::Result> { loop { diff --git a/gen/youtubeanalytics1/src/lib.rs b/gen/youtubeanalytics1/src/lib.rs index 89086eb3001..271fbda9f22 100644 --- a/gen/youtubeanalytics1/src/lib.rs +++ b/gen/youtubeanalytics1/src/lib.rs @@ -2,7 +2,7 @@ // This file was generated automatically from 'src/mako/api/lib.rs.mako' // DO NOT EDIT ! -//! This documentation was generated from *YouTube Analytics* crate version *0.1.4+20150304*, where *20150304* is the exact revision of the *youtubeAnalytics:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.4*. +//! This documentation was generated from *YouTube Analytics* crate version *0.1.5+20150304*, where *20150304* is the exact revision of the *youtubeAnalytics:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.5*. //! //! Everything else about the *YouTube Analytics* *v1* API can be found at the //! [official documentation site](http://developers.google.com/youtube/analytics/). @@ -202,7 +202,6 @@ use std::cell::RefCell; use std::borrow::BorrowMut; use std::default::Default; use std::collections::BTreeMap; -use std::marker::PhantomData; use serde::json; use std::io; use std::fs; @@ -312,46 +311,43 @@ impl Default for Scope { /// } /// # } /// ``` -pub struct YouTubeAnalytics { +pub struct YouTubeAnalytics { client: RefCell, auth: RefCell, _user_agent: String, - - _m: PhantomData } -impl<'a, C, NC, A> Hub for YouTubeAnalytics {} +impl<'a, C, A> Hub for YouTubeAnalytics {} -impl<'a, C, NC, A> YouTubeAnalytics - where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> YouTubeAnalytics + where C: BorrowMut, A: oauth2::GetToken { - pub fn new(client: C, authenticator: A) -> YouTubeAnalytics { + pub fn new(client: C, authenticator: A) -> YouTubeAnalytics { YouTubeAnalytics { client: RefCell::new(client), auth: RefCell::new(authenticator), - _user_agent: "google-api-rust-client/0.1.4".to_string(), - _m: PhantomData + _user_agent: "google-api-rust-client/0.1.5".to_string(), } } - pub fn batch_report_definitions(&'a self) -> BatchReportDefinitionMethods<'a, C, NC, A> { + pub fn batch_report_definitions(&'a self) -> BatchReportDefinitionMethods<'a, C, A> { BatchReportDefinitionMethods { hub: &self } } - pub fn batch_reports(&'a self) -> BatchReportMethods<'a, C, NC, A> { + pub fn batch_reports(&'a self) -> BatchReportMethods<'a, C, A> { BatchReportMethods { hub: &self } } - pub fn group_items(&'a self) -> GroupItemMethods<'a, C, NC, A> { + pub fn group_items(&'a self) -> GroupItemMethods<'a, C, A> { GroupItemMethods { hub: &self } } - pub fn groups(&'a self) -> GroupMethods<'a, C, NC, A> { + pub fn groups(&'a self) -> GroupMethods<'a, C, A> { GroupMethods { hub: &self } } - pub fn reports(&'a self) -> ReportMethods<'a, C, NC, A> { + pub fn reports(&'a self) -> ReportMethods<'a, C, A> { ReportMethods { hub: &self } } /// Set the user-agent header field to use in all requests to the server. - /// It defaults to `google-api-rust-client/0.1.4`. + /// It defaults to `google-api-rust-client/0.1.5`. /// /// Returns the previously set user-agent. pub fn user_agent(&mut self, agent_name: String) -> String { @@ -735,15 +731,15 @@ impl ResponseResult for BatchReportList {} /// let rb = hub.reports(); /// # } /// ``` -pub struct ReportMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTubeAnalytics, + hub: &'a YouTubeAnalytics, } -impl<'a, C, NC, A> MethodsBuilder for ReportMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for ReportMethods<'a, C, A> {} -impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { +impl<'a, C, A> ReportMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -757,7 +753,7 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// * `start-date` - The start date for fetching YouTube Analytics data. The value should be in YYYY-MM-DD format. /// * `end-date` - The end date for fetching YouTube Analytics data. The value should be in YYYY-MM-DD format. /// * `metrics` - A comma-separated list of YouTube Analytics metrics, such as views or likes,dislikes. See the Available Reports document for a list of the reports that you can retrieve and the metrics available in each report, and see the Metrics document for definitions of those metrics. - pub fn query(&self, ids: &str, start_date: &str, end_date: &str, metrics: &str) -> ReportQueryCall<'a, C, NC, A> { + pub fn query(&self, ids: &str, start_date: &str, end_date: &str, metrics: &str) -> ReportQueryCall<'a, C, A> { ReportQueryCall { hub: self.hub, _ids: ids.to_string(), @@ -807,15 +803,15 @@ impl<'a, C, NC, A> ReportMethods<'a, C, NC, A> { /// let rb = hub.batch_report_definitions(); /// # } /// ``` -pub struct BatchReportDefinitionMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BatchReportDefinitionMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTubeAnalytics, + hub: &'a YouTubeAnalytics, } -impl<'a, C, NC, A> MethodsBuilder for BatchReportDefinitionMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for BatchReportDefinitionMethods<'a, C, A> {} -impl<'a, C, NC, A> BatchReportDefinitionMethods<'a, C, NC, A> { +impl<'a, C, A> BatchReportDefinitionMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -824,7 +820,7 @@ impl<'a, C, NC, A> BatchReportDefinitionMethods<'a, C, NC, A> { /// # Arguments /// /// * `onBehalfOfContentOwner` - The onBehalfOfContentOwner parameter identifies the content owner that the user is acting on behalf of. - pub fn list(&self, on_behalf_of_content_owner: &str) -> BatchReportDefinitionListCall<'a, C, NC, A> { + pub fn list(&self, on_behalf_of_content_owner: &str) -> BatchReportDefinitionListCall<'a, C, A> { BatchReportDefinitionListCall { hub: self.hub, _on_behalf_of_content_owner: on_behalf_of_content_owner.to_string(), @@ -865,15 +861,15 @@ impl<'a, C, NC, A> BatchReportDefinitionMethods<'a, C, NC, A> { /// let rb = hub.group_items(); /// # } /// ``` -pub struct GroupItemMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GroupItemMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTubeAnalytics, + hub: &'a YouTubeAnalytics, } -impl<'a, C, NC, A> MethodsBuilder for GroupItemMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for GroupItemMethods<'a, C, A> {} -impl<'a, C, NC, A> GroupItemMethods<'a, C, NC, A> { +impl<'a, C, A> GroupItemMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -882,7 +878,7 @@ impl<'a, C, NC, A> GroupItemMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &GroupItem) -> GroupItemInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &GroupItem) -> GroupItemInsertCall<'a, C, A> { GroupItemInsertCall { hub: self.hub, _request: request.clone(), @@ -900,7 +896,7 @@ impl<'a, C, NC, A> GroupItemMethods<'a, C, NC, A> { /// # Arguments /// /// * `groupId` - The id parameter specifies the unique ID of the group for which you want to retrieve group items. - pub fn list(&self, group_id: &str) -> GroupItemListCall<'a, C, NC, A> { + pub fn list(&self, group_id: &str) -> GroupItemListCall<'a, C, A> { GroupItemListCall { hub: self.hub, _group_id: group_id.to_string(), @@ -918,7 +914,7 @@ impl<'a, C, NC, A> GroupItemMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The id parameter specifies the YouTube group item ID for the group that is being deleted. - pub fn delete(&self, id: &str) -> GroupItemDeleteCall<'a, C, NC, A> { + pub fn delete(&self, id: &str) -> GroupItemDeleteCall<'a, C, A> { GroupItemDeleteCall { hub: self.hub, _id: id.to_string(), @@ -960,15 +956,15 @@ impl<'a, C, NC, A> GroupItemMethods<'a, C, NC, A> { /// let rb = hub.groups(); /// # } /// ``` -pub struct GroupMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GroupMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTubeAnalytics, + hub: &'a YouTubeAnalytics, } -impl<'a, C, NC, A> MethodsBuilder for GroupMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for GroupMethods<'a, C, A> {} -impl<'a, C, NC, A> GroupMethods<'a, C, NC, A> { +impl<'a, C, A> GroupMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -977,7 +973,7 @@ impl<'a, C, NC, A> GroupMethods<'a, C, NC, A> { /// # Arguments /// /// * `id` - The id parameter specifies the YouTube group ID for the group that is being deleted. - pub fn delete(&self, id: &str) -> GroupDeleteCall<'a, C, NC, A> { + pub fn delete(&self, id: &str) -> GroupDeleteCall<'a, C, A> { GroupDeleteCall { hub: self.hub, _id: id.to_string(), @@ -995,7 +991,7 @@ impl<'a, C, NC, A> GroupMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn insert(&self, request: &Group) -> GroupInsertCall<'a, C, NC, A> { + pub fn insert(&self, request: &Group) -> GroupInsertCall<'a, C, A> { GroupInsertCall { hub: self.hub, _request: request.clone(), @@ -1009,7 +1005,7 @@ impl<'a, C, NC, A> GroupMethods<'a, C, NC, A> { /// Create a builder to help you perform the following task: /// /// Returns a collection of groups that match the API request parameters. For example, you can retrieve all groups that the authenticated user owns, or you can retrieve one or more groups by their unique IDs. - pub fn list(&self) -> GroupListCall<'a, C, NC, A> { + pub fn list(&self) -> GroupListCall<'a, C, A> { GroupListCall { hub: self.hub, _on_behalf_of_content_owner: Default::default(), @@ -1028,7 +1024,7 @@ impl<'a, C, NC, A> GroupMethods<'a, C, NC, A> { /// # Arguments /// /// * `request` - No description provided. - pub fn update(&self, request: &Group) -> GroupUpdateCall<'a, C, NC, A> { + pub fn update(&self, request: &Group) -> GroupUpdateCall<'a, C, A> { GroupUpdateCall { hub: self.hub, _request: request.clone(), @@ -1070,15 +1066,15 @@ impl<'a, C, NC, A> GroupMethods<'a, C, NC, A> { /// let rb = hub.batch_reports(); /// # } /// ``` -pub struct BatchReportMethods<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BatchReportMethods<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTubeAnalytics, + hub: &'a YouTubeAnalytics, } -impl<'a, C, NC, A> MethodsBuilder for BatchReportMethods<'a, C, NC, A> {} +impl<'a, C, A> MethodsBuilder for BatchReportMethods<'a, C, A> {} -impl<'a, C, NC, A> BatchReportMethods<'a, C, NC, A> { +impl<'a, C, A> BatchReportMethods<'a, C, A> { /// Create a builder to help you perform the following task: /// @@ -1088,7 +1084,7 @@ impl<'a, C, NC, A> BatchReportMethods<'a, C, NC, A> { /// /// * `batchReportDefinitionId` - The batchReportDefinitionId parameter specifies the ID of the batch reportort definition for which you are retrieving reports. /// * `onBehalfOfContentOwner` - The onBehalfOfContentOwner parameter identifies the content owner that the user is acting on behalf of. - pub fn list(&self, batch_report_definition_id: &str, on_behalf_of_content_owner: &str) -> BatchReportListCall<'a, C, NC, A> { + pub fn list(&self, batch_report_definition_id: &str, on_behalf_of_content_owner: &str) -> BatchReportListCall<'a, C, A> { BatchReportListCall { hub: self.hub, _batch_report_definition_id: batch_report_definition_id.to_string(), @@ -1144,10 +1140,10 @@ impl<'a, C, NC, A> BatchReportMethods<'a, C, NC, A> { /// .doit(); /// # } /// ``` -pub struct ReportQueryCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct ReportQueryCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTubeAnalytics, + hub: &'a YouTubeAnalytics, _ids: String, _start_date: String, _end_date: String, @@ -1163,9 +1159,9 @@ pub struct ReportQueryCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for ReportQueryCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for ReportQueryCall<'a, C, A> {} -impl<'a, C, NC, A> ReportQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> ReportQueryCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1296,7 +1292,7 @@ impl<'a, C, NC, A> ReportQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Identifies the YouTube channel or content owner for which you are retrieving YouTube Analytics data. /// - To request data for a YouTube user, set the ids parameter value to channel==CHANNEL_ID, where CHANNEL_ID specifies the unique YouTube channel ID. /// - To request data for a YouTube CMS content owner, set the ids parameter value to contentOwner==OWNER_NAME, where OWNER_NAME is the CMS name of the content owner. - pub fn ids(mut self, new_value: &str) -> ReportQueryCall<'a, C, NC, A> { + pub fn ids(mut self, new_value: &str) -> ReportQueryCall<'a, C, A> { self._ids = new_value.to_string(); self } @@ -1306,7 +1302,7 @@ impl<'a, C, NC, A> ReportQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The start date for fetching YouTube Analytics data. The value should be in YYYY-MM-DD format. - pub fn start_date(mut self, new_value: &str) -> ReportQueryCall<'a, C, NC, A> { + pub fn start_date(mut self, new_value: &str) -> ReportQueryCall<'a, C, A> { self._start_date = new_value.to_string(); self } @@ -1316,7 +1312,7 @@ impl<'a, C, NC, A> ReportQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The end date for fetching YouTube Analytics data. The value should be in YYYY-MM-DD format. - pub fn end_date(mut self, new_value: &str) -> ReportQueryCall<'a, C, NC, A> { + pub fn end_date(mut self, new_value: &str) -> ReportQueryCall<'a, C, A> { self._end_date = new_value.to_string(); self } @@ -1326,7 +1322,7 @@ impl<'a, C, NC, A> ReportQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// A comma-separated list of YouTube Analytics metrics, such as views or likes,dislikes. See the Available Reports document for a list of the reports that you can retrieve and the metrics available in each report, and see the Metrics document for definitions of those metrics. - pub fn metrics(mut self, new_value: &str) -> ReportQueryCall<'a, C, NC, A> { + pub fn metrics(mut self, new_value: &str) -> ReportQueryCall<'a, C, A> { self._metrics = new_value.to_string(); self } @@ -1334,7 +1330,7 @@ impl<'a, C, NC, A> ReportQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// An index of the first entity to retrieve. Use this parameter as a pagination mechanism along with the max-results parameter (one-based, inclusive). - pub fn start_index(mut self, new_value: i32) -> ReportQueryCall<'a, C, NC, A> { + pub fn start_index(mut self, new_value: i32) -> ReportQueryCall<'a, C, A> { self._start_index = Some(new_value); self } @@ -1342,7 +1338,7 @@ impl<'a, C, NC, A> ReportQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// A comma-separated list of dimensions or metrics that determine the sort order for YouTube Analytics data. By default the sort order is ascending. The '-' prefix causes descending sort order. - pub fn sort(mut self, new_value: &str) -> ReportQueryCall<'a, C, NC, A> { + pub fn sort(mut self, new_value: &str) -> ReportQueryCall<'a, C, A> { self._sort = Some(new_value.to_string()); self } @@ -1350,7 +1346,7 @@ impl<'a, C, NC, A> ReportQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The maximum number of rows to include in the response. - pub fn max_results(mut self, new_value: i32) -> ReportQueryCall<'a, C, NC, A> { + pub fn max_results(mut self, new_value: i32) -> ReportQueryCall<'a, C, A> { self._max_results = Some(new_value); self } @@ -1358,7 +1354,7 @@ impl<'a, C, NC, A> ReportQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// A list of filters that should be applied when retrieving YouTube Analytics data. The Available Reports document identifies the dimensions that can be used to filter each report, and the Dimensions document defines those dimensions. If a request uses multiple filters, join them together with a semicolon (;), and the returned result table will satisfy both filters. For example, a filters parameter value of video==dMH0bHeiRNg;country==IT restricts the result set to include data for the given video in Italy. - pub fn filters(mut self, new_value: &str) -> ReportQueryCall<'a, C, NC, A> { + pub fn filters(mut self, new_value: &str) -> ReportQueryCall<'a, C, A> { self._filters = Some(new_value.to_string()); self } @@ -1366,7 +1362,7 @@ impl<'a, C, NC, A> ReportQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// A comma-separated list of YouTube Analytics dimensions, such as views or ageGroup,gender. See the Available Reports document for a list of the reports that you can retrieve and the dimensions used for those reports. Also see the Dimensions document for definitions of those dimensions. - pub fn dimensions(mut self, new_value: &str) -> ReportQueryCall<'a, C, NC, A> { + pub fn dimensions(mut self, new_value: &str) -> ReportQueryCall<'a, C, A> { self._dimensions = Some(new_value.to_string()); self } @@ -1374,7 +1370,7 @@ impl<'a, C, NC, A> ReportQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// /// /// The currency to which financial metrics should be converted. The default is US Dollar (USD). If the result contains no financial metrics, this flag will be ignored. Responds with an error if the specified currency is not recognized. - pub fn currency(mut self, new_value: &str) -> ReportQueryCall<'a, C, NC, A> { + pub fn currency(mut self, new_value: &str) -> ReportQueryCall<'a, C, A> { self._currency = Some(new_value.to_string()); self } @@ -1385,7 +1381,7 @@ impl<'a, C, NC, A> ReportQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportQueryCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> ReportQueryCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1406,7 +1402,7 @@ impl<'a, C, NC, A> ReportQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> ReportQueryCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> ReportQueryCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1423,7 +1419,7 @@ impl<'a, C, NC, A> ReportQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> ReportQueryCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> ReportQueryCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1461,19 +1457,19 @@ impl<'a, C, NC, A> ReportQueryCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct BatchReportDefinitionListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BatchReportDefinitionListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTubeAnalytics, + hub: &'a YouTubeAnalytics, _on_behalf_of_content_owner: String, _delegate: Option<&'a mut Delegate>, _additional_params: HashMap, _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BatchReportDefinitionListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BatchReportDefinitionListCall<'a, C, A> {} -impl<'a, C, NC, A> BatchReportDefinitionListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BatchReportDefinitionListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1581,7 +1577,7 @@ impl<'a, C, NC, A> BatchReportDefinitionListCall<'a, C, NC, A> where NC: hyper:: /// we provide this method for API completeness. /// /// The onBehalfOfContentOwner parameter identifies the content owner that the user is acting on behalf of. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> BatchReportDefinitionListCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> BatchReportDefinitionListCall<'a, C, A> { self._on_behalf_of_content_owner = new_value.to_string(); self } @@ -1592,7 +1588,7 @@ impl<'a, C, NC, A> BatchReportDefinitionListCall<'a, C, NC, A> where NC: hyper:: /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BatchReportDefinitionListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BatchReportDefinitionListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1613,7 +1609,7 @@ impl<'a, C, NC, A> BatchReportDefinitionListCall<'a, C, NC, A> where NC: hyper:: /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BatchReportDefinitionListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BatchReportDefinitionListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1630,7 +1626,7 @@ impl<'a, C, NC, A> BatchReportDefinitionListCall<'a, C, NC, A> where NC: hyper:: /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BatchReportDefinitionListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BatchReportDefinitionListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1675,10 +1671,10 @@ impl<'a, C, NC, A> BatchReportDefinitionListCall<'a, C, NC, A> where NC: hyper:: /// .doit(); /// # } /// ``` -pub struct GroupItemInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GroupItemInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTubeAnalytics, + hub: &'a YouTubeAnalytics, _request: GroupItem, _on_behalf_of_content_owner: Option, _delegate: Option<&'a mut Delegate>, @@ -1686,9 +1682,9 @@ pub struct GroupItemInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GroupItemInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GroupItemInsertCall<'a, C, A> {} -impl<'a, C, NC, A> GroupItemInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GroupItemInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -1805,7 +1801,7 @@ impl<'a, C, NC, A> GroupItemInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &GroupItem) -> GroupItemInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &GroupItem) -> GroupItemInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -1815,7 +1811,7 @@ impl<'a, C, NC, A> GroupItemInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> GroupItemInsertCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> GroupItemInsertCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -1826,7 +1822,7 @@ impl<'a, C, NC, A> GroupItemInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupItemInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupItemInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -1847,7 +1843,7 @@ impl<'a, C, NC, A> GroupItemInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GroupItemInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GroupItemInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -1864,7 +1860,7 @@ impl<'a, C, NC, A> GroupItemInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GroupItemInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GroupItemInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -1903,10 +1899,10 @@ impl<'a, C, NC, A> GroupItemInsertCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct GroupItemListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GroupItemListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTubeAnalytics, + hub: &'a YouTubeAnalytics, _group_id: String, _on_behalf_of_content_owner: Option, _delegate: Option<&'a mut Delegate>, @@ -1914,9 +1910,9 @@ pub struct GroupItemListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GroupItemListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GroupItemListCall<'a, C, A> {} -impl<'a, C, NC, A> GroupItemListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GroupItemListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2027,7 +2023,7 @@ impl<'a, C, NC, A> GroupItemListCall<'a, C, NC, A> where NC: hyper::net::Network /// we provide this method for API completeness. /// /// The id parameter specifies the unique ID of the group for which you want to retrieve group items. - pub fn group_id(mut self, new_value: &str) -> GroupItemListCall<'a, C, NC, A> { + pub fn group_id(mut self, new_value: &str) -> GroupItemListCall<'a, C, A> { self._group_id = new_value.to_string(); self } @@ -2037,7 +2033,7 @@ impl<'a, C, NC, A> GroupItemListCall<'a, C, NC, A> where NC: hyper::net::Network /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> GroupItemListCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> GroupItemListCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -2048,7 +2044,7 @@ impl<'a, C, NC, A> GroupItemListCall<'a, C, NC, A> where NC: hyper::net::Network /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupItemListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupItemListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2069,7 +2065,7 @@ impl<'a, C, NC, A> GroupItemListCall<'a, C, NC, A> where NC: hyper::net::Network /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GroupItemListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GroupItemListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2086,7 +2082,7 @@ impl<'a, C, NC, A> GroupItemListCall<'a, C, NC, A> where NC: hyper::net::Network /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GroupItemListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GroupItemListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2125,10 +2121,10 @@ impl<'a, C, NC, A> GroupItemListCall<'a, C, NC, A> where NC: hyper::net::Network /// .doit(); /// # } /// ``` -pub struct GroupItemDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GroupItemDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTubeAnalytics, + hub: &'a YouTubeAnalytics, _id: String, _on_behalf_of_content_owner: Option, _delegate: Option<&'a mut Delegate>, @@ -2136,9 +2132,9 @@ pub struct GroupItemDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GroupItemDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GroupItemDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> GroupItemDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GroupItemDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2238,7 +2234,7 @@ impl<'a, C, NC, A> GroupItemDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The id parameter specifies the YouTube group item ID for the group that is being deleted. - pub fn id(mut self, new_value: &str) -> GroupItemDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> GroupItemDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -2248,7 +2244,7 @@ impl<'a, C, NC, A> GroupItemDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> GroupItemDeleteCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> GroupItemDeleteCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -2259,7 +2255,7 @@ impl<'a, C, NC, A> GroupItemDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupItemDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupItemDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2280,7 +2276,7 @@ impl<'a, C, NC, A> GroupItemDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GroupItemDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GroupItemDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2297,7 +2293,7 @@ impl<'a, C, NC, A> GroupItemDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GroupItemDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GroupItemDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2336,10 +2332,10 @@ impl<'a, C, NC, A> GroupItemDeleteCall<'a, C, NC, A> where NC: hyper::net::Netwo /// .doit(); /// # } /// ``` -pub struct GroupDeleteCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GroupDeleteCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTubeAnalytics, + hub: &'a YouTubeAnalytics, _id: String, _on_behalf_of_content_owner: Option, _delegate: Option<&'a mut Delegate>, @@ -2347,9 +2343,9 @@ pub struct GroupDeleteCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GroupDeleteCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GroupDeleteCall<'a, C, A> {} -impl<'a, C, NC, A> GroupDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GroupDeleteCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2449,7 +2445,7 @@ impl<'a, C, NC, A> GroupDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// we provide this method for API completeness. /// /// The id parameter specifies the YouTube group ID for the group that is being deleted. - pub fn id(mut self, new_value: &str) -> GroupDeleteCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> GroupDeleteCall<'a, C, A> { self._id = new_value.to_string(); self } @@ -2459,7 +2455,7 @@ impl<'a, C, NC, A> GroupDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> GroupDeleteCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> GroupDeleteCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -2470,7 +2466,7 @@ impl<'a, C, NC, A> GroupDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupDeleteCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupDeleteCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2491,7 +2487,7 @@ impl<'a, C, NC, A> GroupDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GroupDeleteCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GroupDeleteCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2508,7 +2504,7 @@ impl<'a, C, NC, A> GroupDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GroupDeleteCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GroupDeleteCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2553,10 +2549,10 @@ impl<'a, C, NC, A> GroupDeleteCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct GroupInsertCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GroupInsertCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTubeAnalytics, + hub: &'a YouTubeAnalytics, _request: Group, _on_behalf_of_content_owner: Option, _delegate: Option<&'a mut Delegate>, @@ -2564,9 +2560,9 @@ pub struct GroupInsertCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GroupInsertCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GroupInsertCall<'a, C, A> {} -impl<'a, C, NC, A> GroupInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GroupInsertCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2683,7 +2679,7 @@ impl<'a, C, NC, A> GroupInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Group) -> GroupInsertCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Group) -> GroupInsertCall<'a, C, A> { self._request = new_value.clone(); self } @@ -2693,7 +2689,7 @@ impl<'a, C, NC, A> GroupInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> GroupInsertCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> GroupInsertCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -2704,7 +2700,7 @@ impl<'a, C, NC, A> GroupInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupInsertCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupInsertCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2725,7 +2721,7 @@ impl<'a, C, NC, A> GroupInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GroupInsertCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GroupInsertCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2742,7 +2738,7 @@ impl<'a, C, NC, A> GroupInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GroupInsertCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GroupInsertCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -2783,10 +2779,10 @@ impl<'a, C, NC, A> GroupInsertCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct GroupListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GroupListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTubeAnalytics, + hub: &'a YouTubeAnalytics, _on_behalf_of_content_owner: Option, _mine: Option, _id: Option, @@ -2795,9 +2791,9 @@ pub struct GroupListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GroupListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GroupListCall<'a, C, A> {} -impl<'a, C, NC, A> GroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GroupListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -2913,7 +2909,7 @@ impl<'a, C, NC, A> GroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> GroupListCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> GroupListCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -2921,7 +2917,7 @@ impl<'a, C, NC, A> GroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// Set this parameter's value to true to instruct the API to only return groups owned by the authenticated user. - pub fn mine(mut self, new_value: bool) -> GroupListCall<'a, C, NC, A> { + pub fn mine(mut self, new_value: bool) -> GroupListCall<'a, C, A> { self._mine = Some(new_value); self } @@ -2929,7 +2925,7 @@ impl<'a, C, NC, A> GroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// /// /// The id parameter specifies a comma-separated list of the YouTube group ID(s) for the resource(s) that are being retrieved. In a group resource, the id property specifies the group's YouTube group ID. - pub fn id(mut self, new_value: &str) -> GroupListCall<'a, C, NC, A> { + pub fn id(mut self, new_value: &str) -> GroupListCall<'a, C, A> { self._id = Some(new_value.to_string()); self } @@ -2940,7 +2936,7 @@ impl<'a, C, NC, A> GroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -2961,7 +2957,7 @@ impl<'a, C, NC, A> GroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GroupListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GroupListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -2978,7 +2974,7 @@ impl<'a, C, NC, A> GroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GroupListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GroupListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3023,10 +3019,10 @@ impl<'a, C, NC, A> GroupListCall<'a, C, NC, A> where NC: hyper::net::NetworkConn /// .doit(); /// # } /// ``` -pub struct GroupUpdateCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct GroupUpdateCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTubeAnalytics, + hub: &'a YouTubeAnalytics, _request: Group, _on_behalf_of_content_owner: Option, _delegate: Option<&'a mut Delegate>, @@ -3034,9 +3030,9 @@ pub struct GroupUpdateCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for GroupUpdateCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for GroupUpdateCall<'a, C, A> {} -impl<'a, C, NC, A> GroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> GroupUpdateCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3153,7 +3149,7 @@ impl<'a, C, NC, A> GroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Even though the property as already been set when instantiating this call, /// we provide this method for API completeness. /// - pub fn request(mut self, new_value: &Group) -> GroupUpdateCall<'a, C, NC, A> { + pub fn request(mut self, new_value: &Group) -> GroupUpdateCall<'a, C, A> { self._request = new_value.clone(); self } @@ -3163,7 +3159,7 @@ impl<'a, C, NC, A> GroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Note: This parameter is intended exclusively for YouTube content partners. /// /// The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> GroupUpdateCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> GroupUpdateCall<'a, C, A> { self._on_behalf_of_content_owner = Some(new_value.to_string()); self } @@ -3174,7 +3170,7 @@ impl<'a, C, NC, A> GroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupUpdateCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> GroupUpdateCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3195,7 +3191,7 @@ impl<'a, C, NC, A> GroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> GroupUpdateCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> GroupUpdateCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3212,7 +3208,7 @@ impl<'a, C, NC, A> GroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> GroupUpdateCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> GroupUpdateCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self @@ -3250,10 +3246,10 @@ impl<'a, C, NC, A> GroupUpdateCall<'a, C, NC, A> where NC: hyper::net::NetworkCo /// .doit(); /// # } /// ``` -pub struct BatchReportListCall<'a, C, NC, A> - where C: 'a, NC: 'a, A: 'a { +pub struct BatchReportListCall<'a, C, A> + where C: 'a, A: 'a { - hub: &'a YouTubeAnalytics, + hub: &'a YouTubeAnalytics, _batch_report_definition_id: String, _on_behalf_of_content_owner: String, _delegate: Option<&'a mut Delegate>, @@ -3261,9 +3257,9 @@ pub struct BatchReportListCall<'a, C, NC, A> _scopes: BTreeMap } -impl<'a, C, NC, A> CallBuilder for BatchReportListCall<'a, C, NC, A> {} +impl<'a, C, A> CallBuilder for BatchReportListCall<'a, C, A> {} -impl<'a, C, NC, A> BatchReportListCall<'a, C, NC, A> where NC: hyper::net::NetworkConnector, C: BorrowMut>, A: oauth2::GetToken { +impl<'a, C, A> BatchReportListCall<'a, C, A> where C: BorrowMut, A: oauth2::GetToken { /// Perform the operation you have build so far. @@ -3372,7 +3368,7 @@ impl<'a, C, NC, A> BatchReportListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The batchReportDefinitionId parameter specifies the ID of the batch reportort definition for which you are retrieving reports. - pub fn batch_report_definition_id(mut self, new_value: &str) -> BatchReportListCall<'a, C, NC, A> { + pub fn batch_report_definition_id(mut self, new_value: &str) -> BatchReportListCall<'a, C, A> { self._batch_report_definition_id = new_value.to_string(); self } @@ -3382,7 +3378,7 @@ impl<'a, C, NC, A> BatchReportListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// we provide this method for API completeness. /// /// The onBehalfOfContentOwner parameter identifies the content owner that the user is acting on behalf of. - pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> BatchReportListCall<'a, C, NC, A> { + pub fn on_behalf_of_content_owner(mut self, new_value: &str) -> BatchReportListCall<'a, C, A> { self._on_behalf_of_content_owner = new_value.to_string(); self } @@ -3393,7 +3389,7 @@ impl<'a, C, NC, A> BatchReportListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// while executing the actual API request. /// /// It should be used to handle progress information, and to implement a certain level of resilience. - pub fn delegate(mut self, new_value: &'a mut Delegate) -> BatchReportListCall<'a, C, NC, A> { + pub fn delegate(mut self, new_value: &'a mut Delegate) -> BatchReportListCall<'a, C, A> { self._delegate = Some(new_value); self } @@ -3414,7 +3410,7 @@ impl<'a, C, NC, A> BatchReportListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// * *userIp* (query-string) - IP address of the site where the request originates. Use this if you want to enforce per-user limits. /// * *fields* (query-string) - Selector specifying which fields to include in a partial response. /// * *alt* (query-string) - Data format for the response. - pub fn param(mut self, name: T, value: T) -> BatchReportListCall<'a, C, NC, A> + pub fn param(mut self, name: T, value: T) -> BatchReportListCall<'a, C, A> where T: AsRef { self._additional_params.insert(name.as_ref().to_string(), value.as_ref().to_string()); self @@ -3431,7 +3427,7 @@ impl<'a, C, NC, A> BatchReportListCall<'a, C, NC, A> where NC: hyper::net::Netwo /// Usually there is more than one suitable scope to authorize an operation, some of which may /// encompass more rights than others. For example, for listing resources, a *read-only* scope will be /// sufficient, a read-write scope will do as well. - pub fn add_scope(mut self, scope: T) -> BatchReportListCall<'a, C, NC, A> + pub fn add_scope(mut self, scope: T) -> BatchReportListCall<'a, C, A> where T: AsRef { self._scopes.insert(scope.as_ref().to_string(), ()); self