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

fix(checkin): latest version of all APIs

Browse Source 
Now CLI and API and the same level
This commit is contained in:
Sebastian Thiel
2015-04-16 22:51:07 +02:00
parent f5f12c5594
commit 4cf0720ef1
222 changed files with 23770 additions and 23809 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
gen/deploymentmanager2_beta1/src/cmn.rs
View File

@@ -4,6 +4,7 @@ use std::io::{self, Read, Seek, Cursor, Write, SeekFrom};
use std;
use std::fmt::{self, Display};
use std::str::FromStr;
use std::error;
use std::thread::sleep_ms;
use mime::{Mime, TopLevel, SubLevel, Attr, Value};
@@ -217,7 +218,7 @@ pub struct DefaultDelegate;
impl Delegate for DefaultDelegate {}
#[derive(Debug)]
pub enum Error {
/// The http connection failed
HttpError(hyper::HttpError),
@@ -247,6 +248,49 @@ pub enum Error {
Failure(hyper::client::Response),
}
impl Display for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
Error::HttpError(ref err) => err.fmt(f),
Error::UploadSizeLimitExceeded(ref resource_size, ref max_size) =>
writeln!(f, "The media size {} exceeds the maximum allowed upload size of {}"
, resource_size, max_size),
Error::MissingAPIKey => {
writeln!(f, "The application's API key was not found in the configuration").ok();
writeln!(f, "It is used as there are no Scopes defined for this method.")
},
Error::MissingToken =>
writeln!(f, "Didn't obtain authentication token from authenticator"),
Error::Cancelled =>
writeln!(f, "Operation cancelled by delegate"),
Error::FieldClash(field) =>
writeln!(f, "The custom parameter '{}' is already provided natively by the CallBuilder.", field),
Error::JsonDecodeError(ref err) => err.fmt(f),
Error::Failure(ref response) =>
writeln!(f, "Http status indicates failure: {:?}", response),
}
}
}
impl error::Error for Error {
fn description(&self) -> &str {
match *self {
Error::HttpError(ref err) => err.description(),
Error::JsonDecodeError(ref err) => err.description(),
_ => "NO DESCRIPTION POSSIBLE - use `Display.fmt()` instead"
}
}
fn cause(&self) -> Option<&error::Error> {
match *self {
Error::HttpError(ref err) => err.cause(),
Error::JsonDecodeError(ref err) => err.cause(),
_ => None
}
}
}
/// A universal result type used as return for all calls.
pub type Result<T> = std::result::Result<T, Error>;

297
gen/deploymentmanager2_beta1/src/lib.rs
View File

@@ -111,16 +111,18 @@
//!
//! match result {
//! Err(e) => match e {
//! Error::HttpError(err) => println!("HTTPERROR: {:?}", err),
//! Error::MissingAPIKey => println!("Auth: Missing API Key - used if there are no scopes"),
//! Error::MissingToken => println!("OAuth2: Missing Token"),
//! Error::Cancelled => println!("Operation canceled by user"),
//! Error::UploadSizeLimitExceeded(size, max_size) => println!("Upload size too big: {} of {}", size, max_size),
//! Error::Failure(_) => println!("General Failure (hyper::client::Response doesn't print)"),
//! Error::FieldClash(clashed_field) => println!("You added custom parameter which is part of builder: {:?}", clashed_field),
//! Error::JsonDecodeError(err) => println!("Couldn't understand server reply - maybe API needs update: {:?}", err),
//! // The Error enum provides details about what exactly happened.
//! // You can also just use its `Debug`, `Display` or `Error` traits
//! Error::HttpError(_)
//! |Error::MissingAPIKey
//! |Error::MissingToken
//! |Error::Cancelled
//! |Error::UploadSizeLimitExceeded(_, _)
//! |Error::Failure(_)
//! |Error::FieldClash(_)
//! |Error::JsonDecodeError(_) => println!("{}", e),
//! },
//! Ok(_) => println!("Success (value doesn't print)"),
//! Ok(res) => println!("Success: {:?}", res),
//! }
//! # }
//! ```
@@ -288,16 +290,18 @@ impl Default for Scope {
///
/// match result {
/// Err(e) => match e {
/// Error::HttpError(err) => println!("HTTPERROR: {:?}", err),
/// Error::MissingAPIKey => println!("Auth: Missing API Key - used if there are no scopes"),
/// Error::MissingToken => println!("OAuth2: Missing Token"),
/// Error::Cancelled => println!("Operation canceled by user"),
/// Error::UploadSizeLimitExceeded(size, max_size) => println!("Upload size too big: {} of {}", size, max_size),
/// Error::Failure(_) => println!("General Failure (hyper::client::Response doesn't print)"),
/// Error::FieldClash(clashed_field) => println!("You added custom parameter which is part of builder: {:?}", clashed_field),
/// Error::JsonDecodeError(err) => println!("Couldn't understand server reply - maybe API needs update: {:?}", err),
/// // The Error enum provides details about what exactly happened.
/// // You can also just use its `Debug`, `Display` or `Error` traits
/// Error::HttpError(_)
/// |Error::MissingAPIKey
/// |Error::MissingToken
/// |Error::Cancelled
/// |Error::UploadSizeLimitExceeded(_, _)
/// |Error::Failure(_)
/// |Error::FieldClash(_)
/// |Error::JsonDecodeError(_) => println!("{}", e),
/// },
/// Ok(_) => println!("Success (value doesn't print)"),
/// Ok(res) => println!("Success: {:?}", res),
/// }
/// # }
/// ```
@@ -361,7 +365,7 @@ impl<'a, C, A> Deploymentmanager<C, A>
/// * [get resources](struct.ResourceGetCall.html) (response)
/// * [list resources](struct.ResourceListCall.html) (none)
///
#[derive(Default, Clone, Debug, Deserialize)]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ResourceType {
/// ! [Output Only] A list of any errors that occurred during deployment.
pub errors: Vec<String>,
@@ -390,7 +394,7 @@ impl ResponseResult for ResourceType {}
///
/// This type is not used in any activity, and only used as *part* of another schema.
///
#[derive(Default, Clone, Debug, Deserialize)]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct OperationWarningsData {
/// ! A key for the warning data.
pub key: String,
@@ -406,7 +410,7 @@ impl Part for OperationWarningsData {}
///
/// This type is not used in any activity, and only used as *part* of another schema.
///
#[derive(Default, Clone, Debug, Deserialize)]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct OperationWarnings {
/// ! Optional human-readable details for this warning.
pub message: String,
@@ -429,7 +433,7 @@ impl Part for OperationWarnings {}
///
/// * [list resources](struct.ResourceListCall.html) (response)
///
#[derive(Default, Clone, Debug, Deserialize)]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ResourcesListResponse {
/// ! A token used to continue a truncated list request.
#[serde(rename="nextPageToken")]
@@ -445,7 +449,7 @@ impl ResponseResult for ResourcesListResponse {}
///
/// This type is not used in any activity, and only used as *part* of another schema.
///
#[derive(Default, Clone, Debug, Deserialize)]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct OperationErrorErrors {
/// ! An optional, human-readable error message.
pub message: String,
@@ -469,7 +473,7 @@ impl Part for OperationErrorErrors {}
/// * [list manifests](struct.ManifestListCall.html) (none)
/// * [get manifests](struct.ManifestGetCall.html) (response)
///
#[derive(Default, Clone, Debug, Deserialize)]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Manifest {
/// ! [Output Only] The fully-expanded configuration file, including any ! templates and references.
#[serde(rename="evaluatedConfig")]
@@ -493,7 +497,7 @@ impl ResponseResult for Manifest {}
///
/// This type is not used in any activity, and only used as *part* of another schema.
///
#[derive(Default, Clone, Debug, Deserialize)]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct OperationError {
/// ! The array of errors encountered while processing this operation.
pub errors: Vec<OperationErrorErrors>,
@@ -512,7 +516,7 @@ impl Part for OperationError {}
///
/// * [list types](struct.TypeListCall.html) (response)
///
#[derive(Default, Clone, Debug, Deserialize)]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct TypesListResponse {
/// ! Types supported by Deployment Manager
pub types: Vec<Type>,
@@ -530,7 +534,7 @@ impl ResponseResult for TypesListResponse {}
///
/// * [list deployments](struct.DeploymentListCall.html) (response)
///
#[derive(Default, Clone, Debug, Deserialize)]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct DeploymentsListResponse {
/// ! A token used to continue a truncated list request.
#[serde(rename="nextPageToken")]
@@ -583,7 +587,7 @@ impl ResponseResult for Deployment {}
///
/// * [list operations](struct.OperationListCall.html) (response)
///
#[derive(Default, Clone, Debug, Deserialize)]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct OperationsListResponse {
/// ! A token used to continue a truncated list request.
#[serde(rename="nextPageToken")]
@@ -607,7 +611,7 @@ impl ResponseResult for OperationsListResponse {}
/// * [get operations](struct.OperationGetCall.html) (response)
/// * [insert deployments](struct.DeploymentInsertCall.html) (response)
///
#[derive(Default, Clone, Debug, Deserialize)]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Operation {
/// ! [Output Only] Status of the operation. Can be one of the following: ! "PENDING", "RUNNING", or "DONE".
pub status: String,
@@ -671,7 +675,7 @@ impl ResponseResult for Operation {}
///
/// * [list types](struct.TypeListCall.html) (none)
///
#[derive(Default, Clone, Debug, Deserialize)]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct Type {
/// ! Name of the type.
pub name: Option<String>,
@@ -689,7 +693,7 @@ impl Resource for Type {}
///
/// * [list manifests](struct.ManifestListCall.html) (response)
///
#[derive(Default, Clone, Debug, Deserialize)]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ManifestsListResponse {
/// ! A token used to continue a truncated list request.
#[serde(rename="nextPageToken")]
@@ -1304,33 +1308,32 @@ impl<'a, C, A> OperationGetCall<'a, C, A> where C: BorrowMut<hyper::Client>, A:
}
/// ! The project ID for this request.
///
/// Sets the *project* path property to the given value.
///
/// Even though the property as already been set when instantiating this call,
/// we provide this method for API completeness.
///
/// ! The project ID for this request.
pub fn project(mut self, new_value: &str) -> OperationGetCall<'a, C, A> {
self._project = new_value.to_string();
self
}
/// ! The name of the operation for this request.
///
/// Sets the *operation* path property to the given value.
///
/// Even though the property as already been set when instantiating this call,
/// 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, A> {
self._operation = new_value.to_string();
self
}
/// Sets the *delegate* property to the given value.
///
///
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
/// while executing the actual API request.
///
/// It should be used to handle progress information, and to implement a certain level of resilience.
///
/// Sets the *delegate* property to the given value.
pub fn delegate(mut self, new_value: &'a mut Delegate) -> OperationGetCall<'a, C, A> {
self._delegate = Some(new_value);
self
@@ -1360,8 +1363,8 @@ impl<'a, C, A> OperationGetCall<'a, C, A> where C: BorrowMut<hyper::Client>, A:
/// Identifies the authorization scope for the method you are building.
///
/// Use this method to actively specify which scope should be used, instead of relying on the
/// automated algorithm which simply prefers read-only scopes over those who are not.
/// Use this method to actively specify which scope should be used, instead the default `Scope` variant
/// `Scope::NdevCloudmanReadonly`.
///
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
/// tokens for more than one scope.
@@ -1555,39 +1558,36 @@ impl<'a, C, A> OperationListCall<'a, C, A> where C: BorrowMut<hyper::Client>, A:
}
/// ! The project ID for this request.
///
/// Sets the *project* path property to the given value.
///
/// Even though the property as already been set when instantiating this call,
/// we provide this method for API completeness.
///
/// ! The project ID for this request.
pub fn project(mut self, new_value: &str) -> OperationListCall<'a, C, A> {
self._project = new_value.to_string();
self
}
/// Sets the *page token* query property to the given value.
///
///
/// ! 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.
///
/// Sets the *page token* query property to the given value.
pub fn page_token(mut self, new_value: &str) -> OperationListCall<'a, C, A> {
self._page_token = Some(new_value.to_string());
self
}
/// Sets the *max results* query property to the given value.
///
///
/// ! Maximum count of results to be returned. ! Acceptable values are 0 to 100, inclusive. (Default: 50)
///
/// Sets the *max results* query property to the given value.
pub fn max_results(mut self, new_value: i32) -> OperationListCall<'a, C, A> {
self._max_results = Some(new_value);
self
}
/// Sets the *delegate* property to the given value.
///
///
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
/// while executing the actual API request.
///
/// It should be used to handle progress information, and to implement a certain level of resilience.
///
/// Sets the *delegate* property to the given value.
pub fn delegate(mut self, new_value: &'a mut Delegate) -> OperationListCall<'a, C, A> {
self._delegate = Some(new_value);
self
@@ -1617,8 +1617,8 @@ impl<'a, C, A> OperationListCall<'a, C, A> where C: BorrowMut<hyper::Client>, A:
/// Identifies the authorization scope for the method you are building.
///
/// Use this method to actively specify which scope should be used, instead of relying on the
/// automated algorithm which simply prefers read-only scopes over those who are not.
/// Use this method to actively specify which scope should be used, instead the default `Scope` variant
/// `Scope::NdevCloudmanReadonly`.
///
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
/// tokens for more than one scope.
@@ -1817,32 +1817,31 @@ impl<'a, C, A> DeploymentInsertCall<'a, C, A> where C: BorrowMut<hyper::Client>,
}
///
/// Sets the *request* property to the given value.
///
/// Even though 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, A> {
self._request = new_value.clone();
self
}
/// ! The project ID for this request.
///
/// Sets the *project* path property to the given value.
///
/// Even though the property as already been set when instantiating this call,
/// we provide this method for API completeness.
///
/// ! The project ID for this request.
pub fn project(mut self, new_value: &str) -> DeploymentInsertCall<'a, C, A> {
self._project = new_value.to_string();
self
}
/// Sets the *delegate* property to the given value.
///
///
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
/// while executing the actual API request.
///
/// It should be used to handle progress information, and to implement a certain level of resilience.
///
/// Sets the *delegate* property to the given value.
pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeploymentInsertCall<'a, C, A> {
self._delegate = Some(new_value);
self
@@ -1872,8 +1871,8 @@ impl<'a, C, A> DeploymentInsertCall<'a, C, A> where C: BorrowMut<hyper::Client>,
/// Identifies the authorization scope for the method you are building.
///
/// Use this method to actively specify which scope should be used, instead of relying on the
/// automated algorithm which simply prefers read-only scopes over those who are not.
/// Use this method to actively specify which scope should be used, instead the default `Scope` variant
/// `Scope::CloudPlatform`.
///
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
/// tokens for more than one scope.
@@ -2059,33 +2058,32 @@ impl<'a, C, A> DeploymentGetCall<'a, C, A> where C: BorrowMut<hyper::Client>, A:
}
/// ! The project ID for this request.
///
/// Sets the *project* path property to the given value.
///
/// Even though the property as already been set when instantiating this call,
/// we provide this method for API completeness.
///
/// ! The project ID for this request.
pub fn project(mut self, new_value: &str) -> DeploymentGetCall<'a, C, A> {
self._project = new_value.to_string();
self
}
/// ! The name of the deployment for this request.
///
/// Sets the *deployment* path property to the given value.
///
/// Even though the property as already been set when instantiating this call,
/// 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, A> {
self._deployment = new_value.to_string();
self
}
/// Sets the *delegate* property to the given value.
///
///
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
/// while executing the actual API request.
///
/// It should be used to handle progress information, and to implement a certain level of resilience.
///
/// Sets the *delegate* property to the given value.
pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeploymentGetCall<'a, C, A> {
self._delegate = Some(new_value);
self
@@ -2115,8 +2113,8 @@ impl<'a, C, A> DeploymentGetCall<'a, C, A> where C: BorrowMut<hyper::Client>, A:
/// Identifies the authorization scope for the method you are building.
///
/// Use this method to actively specify which scope should be used, instead of relying on the
/// automated algorithm which simply prefers read-only scopes over those who are not.
/// Use this method to actively specify which scope should be used, instead the default `Scope` variant
/// `Scope::NdevCloudmanReadonly`.
///
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
/// tokens for more than one scope.
@@ -2310,39 +2308,36 @@ impl<'a, C, A> DeploymentListCall<'a, C, A> where C: BorrowMut<hyper::Client>, A
}
/// ! The project ID for this request.
///
/// Sets the *project* path property to the given value.
///
/// Even though the property as already been set when instantiating this call,
/// we provide this method for API completeness.
///
/// ! The project ID for this request.
pub fn project(mut self, new_value: &str) -> DeploymentListCall<'a, C, A> {
self._project = new_value.to_string();
self
}
/// Sets the *page token* query property to the given value.
///
///
/// ! 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.
///
/// Sets the *page token* query property to the given value.
pub fn page_token(mut self, new_value: &str) -> DeploymentListCall<'a, C, A> {
self._page_token = Some(new_value.to_string());
self
}
/// Sets the *max results* query property to the given value.
///
///
/// ! Maximum count of results to be returned. ! Acceptable values are 0 to 100, inclusive. (Default: 50)
///
/// Sets the *max results* query property to the given value.
pub fn max_results(mut self, new_value: i32) -> DeploymentListCall<'a, C, A> {
self._max_results = Some(new_value);
self
}
/// Sets the *delegate* property to the given value.
///
///
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
/// while executing the actual API request.
///
/// It should be used to handle progress information, and to implement a certain level of resilience.
///
/// Sets the *delegate* property to the given value.
pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeploymentListCall<'a, C, A> {
self._delegate = Some(new_value);
self
@@ -2372,8 +2367,8 @@ impl<'a, C, A> DeploymentListCall<'a, C, A> where C: BorrowMut<hyper::Client>, A
/// Identifies the authorization scope for the method you are building.
///
/// Use this method to actively specify which scope should be used, instead of relying on the
/// automated algorithm which simply prefers read-only scopes over those who are not.
/// Use this method to actively specify which scope should be used, instead the default `Scope` variant
/// `Scope::NdevCloudmanReadonly`.
///
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
/// tokens for more than one scope.
@@ -2559,33 +2554,32 @@ impl<'a, C, A> DeploymentDeleteCall<'a, C, A> where C: BorrowMut<hyper::Client>,
}
/// ! The project ID for this request.
///
/// Sets the *project* path property to the given value.
///
/// Even though the property as already been set when instantiating this call,
/// we provide this method for API completeness.
///
/// ! The project ID for this request.
pub fn project(mut self, new_value: &str) -> DeploymentDeleteCall<'a, C, A> {
self._project = new_value.to_string();
self
}
/// ! The name of the deployment for this request.
///
/// Sets the *deployment* path property to the given value.
///
/// Even though the property as already been set when instantiating this call,
/// 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, A> {
self._deployment = new_value.to_string();
self
}
/// Sets the *delegate* property to the given value.
///
///
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
/// while executing the actual API request.
///
/// It should be used to handle progress information, and to implement a certain level of resilience.
///
/// Sets the *delegate* property to the given value.
pub fn delegate(mut self, new_value: &'a mut Delegate) -> DeploymentDeleteCall<'a, C, A> {
self._delegate = Some(new_value);
self
@@ -2615,8 +2609,8 @@ impl<'a, C, A> DeploymentDeleteCall<'a, C, A> where C: BorrowMut<hyper::Client>,
/// Identifies the authorization scope for the method you are building.
///
/// Use this method to actively specify which scope should be used, instead of relying on the
/// automated algorithm which simply prefers read-only scopes over those who are not.
/// Use this method to actively specify which scope should be used, instead the default `Scope` variant
/// `Scope::CloudPlatform`.
///
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
/// tokens for more than one scope.
@@ -2810,39 +2804,36 @@ impl<'a, C, A> TypeListCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: oaut
}
/// ! The project ID for this request.
///
/// Sets the *project* path property to the given value.
///
/// Even though the property as already been set when instantiating this call,
/// we provide this method for API completeness.
///
/// ! The project ID for this request.
pub fn project(mut self, new_value: &str) -> TypeListCall<'a, C, A> {
self._project = new_value.to_string();
self
}
/// Sets the *page token* query property to the given value.
///
///
/// ! 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.
///
/// Sets the *page token* query property to the given value.
pub fn page_token(mut self, new_value: &str) -> TypeListCall<'a, C, A> {
self._page_token = Some(new_value.to_string());
self
}
/// Sets the *max results* query property to the given value.
///
///
/// ! Maximum count of results to be returned. ! Acceptable values are 0 to 100, inclusive. (Default: 50)
///
/// Sets the *max results* query property to the given value.
pub fn max_results(mut self, new_value: i32) -> TypeListCall<'a, C, A> {
self._max_results = Some(new_value);
self
}
/// Sets the *delegate* property to the given value.
///
///
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
/// while executing the actual API request.
///
/// It should be used to handle progress information, and to implement a certain level of resilience.
///
/// Sets the *delegate* property to the given value.
pub fn delegate(mut self, new_value: &'a mut Delegate) -> TypeListCall<'a, C, A> {
self._delegate = Some(new_value);
self
@@ -2872,8 +2863,8 @@ impl<'a, C, A> TypeListCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: oaut
/// Identifies the authorization scope for the method you are building.
///
/// Use this method to actively specify which scope should be used, instead of relying on the
/// automated algorithm which simply prefers read-only scopes over those who are not.
/// Use this method to actively specify which scope should be used, instead the default `Scope` variant
/// `Scope::NdevCloudmanReadonly`.
///
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
/// tokens for more than one scope.
@@ -3061,43 +3052,42 @@ impl<'a, C, A> ResourceGetCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: o
}
/// ! The project ID for this request.
///
/// Sets the *project* path property to the given value.
///
/// Even though the property as already been set when instantiating this call,
/// we provide this method for API completeness.
///
/// ! The project ID for this request.
pub fn project(mut self, new_value: &str) -> ResourceGetCall<'a, C, A> {
self._project = new_value.to_string();
self
}
/// ! The name of the deployment for this request.
///
/// Sets the *deployment* path property to the given value.
///
/// Even though the property as already been set when instantiating this call,
/// 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, A> {
self._deployment = new_value.to_string();
self
}
/// ! The name of the resource for this request.
///
/// Sets the *resource* path property to the given value.
///
/// Even though the property as already been set when instantiating this call,
/// 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, A> {
self._resource = new_value.to_string();
self
}
/// Sets the *delegate* property to the given value.
///
///
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
/// while executing the actual API request.
///
/// It should be used to handle progress information, and to implement a certain level of resilience.
///
/// Sets the *delegate* property to the given value.
pub fn delegate(mut self, new_value: &'a mut Delegate) -> ResourceGetCall<'a, C, A> {
self._delegate = Some(new_value);
self
@@ -3127,8 +3117,8 @@ impl<'a, C, A> ResourceGetCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: o
/// Identifies the authorization scope for the method you are building.
///
/// Use this method to actively specify which scope should be used, instead of relying on the
/// automated algorithm which simply prefers read-only scopes over those who are not.
/// Use this method to actively specify which scope should be used, instead the default `Scope` variant
/// `Scope::NdevCloudmanReadonly`.
///
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
/// tokens for more than one scope.
@@ -3324,49 +3314,46 @@ impl<'a, C, A> ResourceListCall<'a, C, A> where C: BorrowMut<hyper::Client>, A:
}
/// ! The project ID for this request.
///
/// Sets the *project* path property to the given value.
///
/// Even though the property as already been set when instantiating this call,
/// we provide this method for API completeness.
///
/// ! The project ID for this request.
pub fn project(mut self, new_value: &str) -> ResourceListCall<'a, C, A> {
self._project = new_value.to_string();
self
}
/// ! The name of the deployment for this request.
///
/// Sets the *deployment* path property to the given value.
///
/// Even though the property as already been set when instantiating this call,
/// 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, A> {
self._deployment = new_value.to_string();
self
}
/// Sets the *page token* query property to the given value.
///
///
/// ! 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.
///
/// Sets the *page token* query property to the given value.
pub fn page_token(mut self, new_value: &str) -> ResourceListCall<'a, C, A> {
self._page_token = Some(new_value.to_string());
self
}
/// Sets the *max results* query property to the given value.
///
///
/// ! Maximum count of results to be returned. ! Acceptable values are 0 to 100, inclusive. (Default: 50)
///
/// Sets the *max results* query property to the given value.
pub fn max_results(mut self, new_value: i32) -> ResourceListCall<'a, C, A> {
self._max_results = Some(new_value);
self
}
/// Sets the *delegate* property to the given value.
///
///
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
/// while executing the actual API request.
///
/// It should be used to handle progress information, and to implement a certain level of resilience.
///
/// Sets the *delegate* property to the given value.
pub fn delegate(mut self, new_value: &'a mut Delegate) -> ResourceListCall<'a, C, A> {
self._delegate = Some(new_value);
self
@@ -3396,8 +3383,8 @@ impl<'a, C, A> ResourceListCall<'a, C, A> where C: BorrowMut<hyper::Client>, A:
/// Identifies the authorization scope for the method you are building.
///
/// Use this method to actively specify which scope should be used, instead of relying on the
/// automated algorithm which simply prefers read-only scopes over those who are not.
/// Use this method to actively specify which scope should be used, instead the default `Scope` variant
/// `Scope::NdevCloudmanReadonly`.
///
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
/// tokens for more than one scope.
@@ -3593,49 +3580,46 @@ impl<'a, C, A> ManifestListCall<'a, C, A> where C: BorrowMut<hyper::Client>, A:
}
/// ! The project ID for this request.
///
/// Sets the *project* path property to the given value.
///
/// Even though the property as already been set when instantiating this call,
/// we provide this method for API completeness.
///
/// ! The project ID for this request.
pub fn project(mut self, new_value: &str) -> ManifestListCall<'a, C, A> {
self._project = new_value.to_string();
self
}
/// ! The name of the deployment for this request.
///
/// Sets the *deployment* path property to the given value.
///
/// Even though the property as already been set when instantiating this call,
/// 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, A> {
self._deployment = new_value.to_string();
self
}
/// Sets the *page token* query property to the given value.
///
///
/// ! 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.
///
/// Sets the *page token* query property to the given value.
pub fn page_token(mut self, new_value: &str) -> ManifestListCall<'a, C, A> {
self._page_token = Some(new_value.to_string());
self
}
/// Sets the *max results* query property to the given value.
///
///
/// ! Maximum count of results to be returned. ! Acceptable values are 0 to 100, inclusive. (Default: 50)
///
/// Sets the *max results* query property to the given value.
pub fn max_results(mut self, new_value: i32) -> ManifestListCall<'a, C, A> {
self._max_results = Some(new_value);
self
}
/// Sets the *delegate* property to the given value.
///
///
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
/// while executing the actual API request.
///
/// It should be used to handle progress information, and to implement a certain level of resilience.
///
/// Sets the *delegate* property to the given value.
pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManifestListCall<'a, C, A> {
self._delegate = Some(new_value);
self
@@ -3665,8 +3649,8 @@ impl<'a, C, A> ManifestListCall<'a, C, A> where C: BorrowMut<hyper::Client>, A:
/// Identifies the authorization scope for the method you are building.
///
/// Use this method to actively specify which scope should be used, instead of relying on the
/// automated algorithm which simply prefers read-only scopes over those who are not.
/// Use this method to actively specify which scope should be used, instead the default `Scope` variant
/// `Scope::NdevCloudmanReadonly`.
///
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
/// tokens for more than one scope.
@@ -3854,43 +3838,42 @@ impl<'a, C, A> ManifestGetCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: o
}
/// ! The project ID for this request.
///
/// Sets the *project* path property to the given value.
///
/// Even though the property as already been set when instantiating this call,
/// we provide this method for API completeness.
///
/// ! The project ID for this request.
pub fn project(mut self, new_value: &str) -> ManifestGetCall<'a, C, A> {
self._project = new_value.to_string();
self
}
/// ! The name of the deployment for this request.
///
/// Sets the *deployment* path property to the given value.
///
/// Even though the property as already been set when instantiating this call,
/// 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, A> {
self._deployment = new_value.to_string();
self
}
/// ! The name of the manifest for this request.
///
/// Sets the *manifest* path property to the given value.
///
/// Even though the property as already been set when instantiating this call,
/// 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, A> {
self._manifest = new_value.to_string();
self
}
/// Sets the *delegate* property to the given value.
///
///
/// The delegate implementation is consulted whenever there is an intermediate result, or if something goes wrong
/// while executing the actual API request.
///
/// It should be used to handle progress information, and to implement a certain level of resilience.
///
/// Sets the *delegate* property to the given value.
pub fn delegate(mut self, new_value: &'a mut Delegate) -> ManifestGetCall<'a, C, A> {
self._delegate = Some(new_value);
self
@@ -3920,8 +3903,8 @@ impl<'a, C, A> ManifestGetCall<'a, C, A> where C: BorrowMut<hyper::Client>, A: o
/// Identifies the authorization scope for the method you are building.
///
/// Use this method to actively specify which scope should be used, instead of relying on the
/// automated algorithm which simply prefers read-only scopes over those who are not.
/// Use this method to actively specify which scope should be used, instead the default `Scope` variant
/// `Scope::NdevCloudmanReadonly`.
///
/// The `scope` will be added to a set of scopes. This is important as one can maintain access
/// tokens for more than one scope.