Mercurial > lbo > hg > async-google-apis

changeset 120:7095f915ec83

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Link to example docs
author Lewin Bormann <lbo@spheniscida.de>
date Sun, 25 Oct 2020 15:07:36 +0100
parents 014f57bedd35
children f14c93b7ab21
files README.md drive_example/Cargo.lock drive_example/src/drive_v3_types.rs gcs_example/src/storage_v1_types.rs generate/templates.py
diffstat 5 files changed, 2644 insertions(+), 1576 deletions(-) [+]
line wrap: on
line diff
--- a/README.md	Sun Oct 25 14:53:07 2020 +0100
+++ b/README.md	Sun Oct 25 15:07:36 2020 +0100
@@ -10,6 +10,14 @@
 successfully, this doesn't mean that it will work on any other current or future
 Google API.
 
+## What it looks like
+
+Consider the documentation of two exemplary APIs:
+
+* [`drive:v3`](https://borgac.net/~lbo/doc/target/doc/drive_example/drive_v3_types/) for Google Drive.
+* ['storage:v1'](https://borgac.net/~lbo/doc/target/doc/gcs_example/storage_v1_types/)
+for Google Cloud Storage.
+
 ## Parts
 
 * `manual_demo` is just a demo crate with some code for developers (well, me) to
--- a/drive_example/Cargo.lock	Sun Oct 25 14:53:07 2020 +0100
+++ b/drive_example/Cargo.lock	Sun Oct 25 15:07:36 2020 +0100
@@ -29,7 +29,7 @@
 
 [[package]]
 name = "async-google-apis-common"
-version = "0.1.5"
+version = "0.1.6"
 dependencies = [
  "anyhow",
  "chrono",
--- a/drive_example/src/drive_v3_types.rs	Sun Oct 25 14:53:07 2020 +0100
+++ b/drive_example/src/drive_v3_types.rs	Sun Oct 25 15:07:36 2020 +0100
@@ -1,9 +1,14 @@
-
 #![allow(unused_variables, unused_mut, dead_code)]
 //! This file was generated by async-google-apis. (https://github.com/dermesser/async-google-apis)
 //!
 //! (c) 2020 Lewin Bormann <lbo@spheniscida.de>
 //!
+//! ## Getting started
+//!
+//! **Tip**: Take a look at those types ending in `...Service`. These represent API resources
+//! and contain methods to interact with an API. The remaining types are used by those methods
+//! and can be explored starting from a method you want to use.
+//!
 //! I'd be happy if you let me know about your use case of this code.
 //!
 //! THIS FILE HAS BEEN GENERATED -- SAVE ANY MODIFICATIONS BEFORE REPLACING.
@@ -54,16 +59,19 @@
             DriveScopes::DriveAppdata => "https://www.googleapis.com/auth/drive.appdata",
             DriveScopes::DriveFile => "https://www.googleapis.com/auth/drive.file",
             DriveScopes::DriveMetadata => "https://www.googleapis.com/auth/drive.metadata",
-            DriveScopes::DriveMetadataReadonly => "https://www.googleapis.com/auth/drive.metadata.readonly",
-            DriveScopes::DrivePhotosReadonly => "https://www.googleapis.com/auth/drive.photos.readonly",
+            DriveScopes::DriveMetadataReadonly => {
+                "https://www.googleapis.com/auth/drive.metadata.readonly"
+            }
+            DriveScopes::DrivePhotosReadonly => {
+                "https://www.googleapis.com/auth/drive.photos.readonly"
+            }
             DriveScopes::DriveReadonly => "https://www.googleapis.com/auth/drive.readonly",
             DriveScopes::DriveScripts => "https://www.googleapis.com/auth/drive.scripts",
         }
     }
 }
 
-
-/// 
+///
 #[derive(Serialize, Deserialize, Debug, Clone, Default)]
 pub struct AboutDriveThemes {
     /// A link to this theme's background image.
@@ -101,7 +109,7 @@
     pub usage_in_drive_trash: Option<String>,
 }
 
-/// 
+///
 #[derive(Serialize, Deserialize, Debug, Clone, Default)]
 pub struct AboutTeamDriveThemes {
     /// Deprecated - use driveThemes/backgroundImageLink instead.
@@ -140,7 +148,7 @@
     /// A map of source MIME type to possible targets for all supported exports.
     #[serde(rename = "exportFormats")]
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub export_formats: Option<HashMap<String,Vec<String>>>,
+    pub export_formats: Option<HashMap<String, Vec<String>>>,
     /// The currently supported folder colors as RGB hex strings.
     #[serde(rename = "folderColorPalette")]
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -148,7 +156,7 @@
     /// A map of source MIME type to possible targets for all supported imports.
     #[serde(rename = "importFormats")]
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub import_formats: Option<HashMap<String,Vec<String>>>,
+    pub import_formats: Option<HashMap<String, Vec<String>>>,
     /// Identifies what kind of resource this is. Value: the fixed string "drive#about".
     #[serde(rename = "kind")]
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -156,7 +164,7 @@
     /// A map of maximum import sizes by MIME type, in bytes.
     #[serde(rename = "maxImportSizes")]
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub max_import_sizes: Option<HashMap<String,String>>,
+    pub max_import_sizes: Option<HashMap<String, String>>,
     /// i64: The maximum upload size in bytes.
     #[serde(rename = "maxUploadSize")]
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -263,7 +271,7 @@
     /// Additional parameters controlling delivery channel behavior. Optional.
     #[serde(rename = "params")]
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub params: Option<HashMap<String,String>>,
+    pub params: Option<HashMap<String, String>>,
     /// A Boolean value to indicate whether payload is wanted. Optional.
     #[serde(rename = "payload")]
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -886,7 +894,7 @@
     /// A collection of arbitrary key-value pairs which are private to the requesting app. Entries with null values are cleared in update and copy requests.
     #[serde(rename = "appProperties")]
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub app_properties: Option<HashMap<String,String>>,
+    pub app_properties: Option<HashMap<String, String>>,
     /// Capabilities the current user has on this file. Each capability corresponds to a fine-grained action that a user may take.
     #[serde(rename = "capabilities")]
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -922,7 +930,7 @@
     /// Links for exporting Google Docs to specific formats.
     #[serde(rename = "exportLinks")]
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub export_links: Option<HashMap<String,String>>,
+    pub export_links: Option<HashMap<String, String>>,
     /// The final component of fullFileExtension. This is only available for files with binary content in Google Drive.
     #[serde(rename = "fileExtension")]
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -1021,7 +1029,7 @@
     /// A collection of arbitrary key-value pairs which are visible to all apps. Entries with null values are cleared in update and copy requests.
     #[serde(rename = "properties")]
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub properties: Option<HashMap<String,String>>,
+    pub properties: Option<HashMap<String, String>>,
     /// i64: The number of storage quota bytes used by the file. This includes the head revision as well as previous revisions with keepForever enabled.
     #[serde(rename = "quotaBytesUsed")]
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -1148,7 +1156,7 @@
     pub space: Option<String>,
 }
 
-/// 
+///
 #[derive(Serialize, Deserialize, Debug, Clone, Default)]
 pub struct PermissionPermissionDetails {
     /// Whether this permission is inherited. This field is always populated. This is an output-only field.
@@ -1169,7 +1177,7 @@
     pub role: Option<String>,
 }
 
-/// 
+///
 #[derive(Serialize, Deserialize, Debug, Clone, Default)]
 pub struct PermissionTeamDrivePermissionDetails {
     /// Deprecated - use permissionDetails/inherited instead.
@@ -1331,7 +1339,7 @@
     /// Links for exporting Google Docs to specific formats.
     #[serde(rename = "exportLinks")]
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub export_links: Option<HashMap<String,String>>,
+    pub export_links: Option<HashMap<String, String>>,
     /// The ID of the revision.
     #[serde(rename = "id")]
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -1402,7 +1410,7 @@
     pub revisions: Option<Vec<Revision>>,
 }
 
-/// 
+///
 #[derive(Serialize, Deserialize, Debug, Clone, Default)]
 pub struct StartPageToken {
     /// Identifies what kind of resource this is. Value: the fixed string "drive#startPageToken".
@@ -1629,7 +1637,7 @@
     pub photo_link: Option<String>,
 }
 
-/// 
+///
 #[derive(Serialize, Deserialize, Debug, Clone, Default)]
 pub struct DriveParams {
     /// Data format for the response.
@@ -1699,16 +1707,32 @@
 impl std::fmt::Display for ChangesGetStartPageTokenParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.drive_id {
-            write!(f, "&driveId={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&driveId={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_all_drives {
-            write!(f, "&supportsAllDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsAllDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_team_drives {
-            write!(f, "&supportsTeamDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsTeamDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.team_drive_id {
-            write!(f, "&teamDriveId={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&teamDriveId={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -1763,42 +1787,94 @@
 
 impl std::fmt::Display for ChangesListParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "&pageToken={}", percent_encode(format!("{}", self.page_token).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+        write!(
+            f,
+            "&pageToken={}",
+            percent_encode(format!("{}", self.page_token).as_bytes(), NON_ALPHANUMERIC).to_string()
+        )?;
         if let Some(ref v) = self.drive_id {
-            write!(f, "&driveId={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&driveId={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.include_corpus_removals {
-            write!(f, "&includeCorpusRemovals={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&includeCorpusRemovals={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.include_items_from_all_drives {
-            write!(f, "&includeItemsFromAllDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&includeItemsFromAllDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.include_permissions_for_view {
-            write!(f, "&includePermissionsForView={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&includePermissionsForView={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.include_removed {
-            write!(f, "&includeRemoved={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&includeRemoved={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.include_team_drive_items {
-            write!(f, "&includeTeamDriveItems={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&includeTeamDriveItems={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.page_size {
-            write!(f, "&pageSize={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&pageSize={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.restrict_to_my_drive {
-            write!(f, "&restrictToMyDrive={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&restrictToMyDrive={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.spaces {
-            write!(f, "&spaces={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&spaces={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_all_drives {
-            write!(f, "&supportsAllDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsAllDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_team_drives {
-            write!(f, "&supportsTeamDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsTeamDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.team_drive_id {
-            write!(f, "&teamDriveId={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&teamDriveId={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -1853,42 +1929,94 @@
 
 impl std::fmt::Display for ChangesWatchParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "&pageToken={}", percent_encode(format!("{}", self.page_token).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+        write!(
+            f,
+            "&pageToken={}",
+            percent_encode(format!("{}", self.page_token).as_bytes(), NON_ALPHANUMERIC).to_string()
+        )?;
         if let Some(ref v) = self.drive_id {
-            write!(f, "&driveId={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&driveId={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.include_corpus_removals {
-            write!(f, "&includeCorpusRemovals={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&includeCorpusRemovals={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.include_items_from_all_drives {
-            write!(f, "&includeItemsFromAllDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&includeItemsFromAllDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.include_permissions_for_view {
-            write!(f, "&includePermissionsForView={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&includePermissionsForView={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.include_removed {
-            write!(f, "&includeRemoved={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&includeRemoved={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.include_team_drive_items {
-            write!(f, "&includeTeamDriveItems={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&includeTeamDriveItems={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.page_size {
-            write!(f, "&pageSize={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&pageSize={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.restrict_to_my_drive {
-            write!(f, "&restrictToMyDrive={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&restrictToMyDrive={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.spaces {
-            write!(f, "&spaces={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&spaces={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_all_drives {
-            write!(f, "&supportsAllDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsAllDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_team_drives {
-            write!(f, "&supportsTeamDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsTeamDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.team_drive_id {
-            write!(f, "&teamDriveId={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&teamDriveId={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -1965,7 +2093,11 @@
 impl std::fmt::Display for CommentsGetParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.include_deleted {
-            write!(f, "&includeDeleted={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&includeDeleted={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -1997,16 +2129,32 @@
 impl std::fmt::Display for CommentsListParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.include_deleted {
-            write!(f, "&includeDeleted={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&includeDeleted={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.page_size {
-            write!(f, "&pageSize={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&pageSize={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.page_token {
-            write!(f, "&pageToken={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&pageToken={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.start_modified_time {
-            write!(f, "&startModifiedTime={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&startModifiedTime={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -2045,7 +2193,11 @@
 
 impl std::fmt::Display for DrivesCreateParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "&requestId={}", percent_encode(format!("{}", self.request_id).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+        write!(
+            f,
+            "&requestId={}",
+            percent_encode(format!("{}", self.request_id).as_bytes(), NON_ALPHANUMERIC).to_string()
+        )?;
         Ok(())
     }
 }
@@ -2084,7 +2236,11 @@
 impl std::fmt::Display for DrivesGetParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.use_domain_admin_access {
-            write!(f, "&useDomainAdminAccess={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&useDomainAdminAccess={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -2130,16 +2286,32 @@
 impl std::fmt::Display for DrivesListParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.page_size {
-            write!(f, "&pageSize={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&pageSize={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.page_token {
-            write!(f, "&pageToken={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&pageToken={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.q {
-            write!(f, "&q={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&q={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.use_domain_admin_access {
-            write!(f, "&useDomainAdminAccess={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&useDomainAdminAccess={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -2179,7 +2351,11 @@
 impl std::fmt::Display for DrivesUpdateParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.use_domain_admin_access {
-            write!(f, "&useDomainAdminAccess={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&useDomainAdminAccess={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -2220,25 +2396,53 @@
 impl std::fmt::Display for FilesCopyParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.enforce_single_parent {
-            write!(f, "&enforceSingleParent={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&enforceSingleParent={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.ignore_default_visibility {
-            write!(f, "&ignoreDefaultVisibility={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&ignoreDefaultVisibility={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.include_permissions_for_view {
-            write!(f, "&includePermissionsForView={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&includePermissionsForView={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.keep_revision_forever {
-            write!(f, "&keepRevisionForever={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&keepRevisionForever={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.ocr_language {
-            write!(f, "&ocrLanguage={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&ocrLanguage={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_all_drives {
-            write!(f, "&supportsAllDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsAllDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_team_drives {
-            write!(f, "&supportsTeamDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsTeamDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -2279,28 +2483,60 @@
 impl std::fmt::Display for FilesCreateParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.enforce_single_parent {
-            write!(f, "&enforceSingleParent={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&enforceSingleParent={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.ignore_default_visibility {
-            write!(f, "&ignoreDefaultVisibility={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&ignoreDefaultVisibility={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.include_permissions_for_view {
-            write!(f, "&includePermissionsForView={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&includePermissionsForView={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.keep_revision_forever {
-            write!(f, "&keepRevisionForever={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&keepRevisionForever={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.ocr_language {
-            write!(f, "&ocrLanguage={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&ocrLanguage={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_all_drives {
-            write!(f, "&supportsAllDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsAllDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_team_drives {
-            write!(f, "&supportsTeamDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsTeamDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.use_content_as_indexable_text {
-            write!(f, "&useContentAsIndexableText={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&useContentAsIndexableText={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -2329,13 +2565,25 @@
 impl std::fmt::Display for FilesDeleteParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.enforce_single_parent {
-            write!(f, "&enforceSingleParent={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&enforceSingleParent={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_all_drives {
-            write!(f, "&supportsAllDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsAllDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_team_drives {
-            write!(f, "&supportsTeamDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsTeamDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -2355,7 +2603,11 @@
 impl std::fmt::Display for FilesEmptyTrashParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.enforce_single_parent {
-            write!(f, "&enforceSingleParent={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&enforceSingleParent={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -2377,7 +2629,11 @@
 
 impl std::fmt::Display for FilesExportParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "&mimeType={}", percent_encode(format!("{}", self.mime_type).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+        write!(
+            f,
+            "&mimeType={}",
+            percent_encode(format!("{}", self.mime_type).as_bytes(), NON_ALPHANUMERIC).to_string()
+        )?;
         Ok(())
     }
 }
@@ -2399,10 +2655,18 @@
 impl std::fmt::Display for FilesGenerateIdsParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.count {
-            write!(f, "&count={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&count={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.space {
-            write!(f, "&space={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&space={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -2434,16 +2698,32 @@
 impl std::fmt::Display for FilesGetParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.acknowledge_abuse {
-            write!(f, "&acknowledgeAbuse={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&acknowledgeAbuse={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.include_permissions_for_view {
-            write!(f, "&includePermissionsForView={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&includePermissionsForView={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_all_drives {
-            write!(f, "&supportsAllDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsAllDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_team_drives {
-            write!(f, "&supportsTeamDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsTeamDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -2502,46 +2782,102 @@
 impl std::fmt::Display for FilesListParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.corpora {
-            write!(f, "&corpora={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&corpora={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.corpus {
-            write!(f, "&corpus={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&corpus={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.drive_id {
-            write!(f, "&driveId={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&driveId={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.include_items_from_all_drives {
-            write!(f, "&includeItemsFromAllDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&includeItemsFromAllDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.include_permissions_for_view {
-            write!(f, "&includePermissionsForView={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&includePermissionsForView={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.include_team_drive_items {
-            write!(f, "&includeTeamDriveItems={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&includeTeamDriveItems={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.order_by {
-            write!(f, "&orderBy={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&orderBy={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.page_size {
-            write!(f, "&pageSize={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&pageSize={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.page_token {
-            write!(f, "&pageToken={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&pageToken={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.q {
-            write!(f, "&q={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&q={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.spaces {
-            write!(f, "&spaces={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&spaces={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_all_drives {
-            write!(f, "&supportsAllDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsAllDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_team_drives {
-            write!(f, "&supportsTeamDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsTeamDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.team_drive_id {
-            write!(f, "&teamDriveId={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&teamDriveId={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -2588,31 +2924,67 @@
 impl std::fmt::Display for FilesUpdateParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.add_parents {
-            write!(f, "&addParents={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&addParents={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.enforce_single_parent {
-            write!(f, "&enforceSingleParent={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&enforceSingleParent={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.include_permissions_for_view {
-            write!(f, "&includePermissionsForView={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&includePermissionsForView={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.keep_revision_forever {
-            write!(f, "&keepRevisionForever={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&keepRevisionForever={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.ocr_language {
-            write!(f, "&ocrLanguage={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&ocrLanguage={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.remove_parents {
-            write!(f, "&removeParents={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&removeParents={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_all_drives {
-            write!(f, "&supportsAllDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsAllDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_team_drives {
-            write!(f, "&supportsTeamDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsTeamDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.use_content_as_indexable_text {
-            write!(f, "&useContentAsIndexableText={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&useContentAsIndexableText={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -2644,16 +3016,32 @@
 impl std::fmt::Display for FilesWatchParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.acknowledge_abuse {
-            write!(f, "&acknowledgeAbuse={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&acknowledgeAbuse={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.include_permissions_for_view {
-            write!(f, "&includePermissionsForView={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&includePermissionsForView={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_all_drives {
-            write!(f, "&supportsAllDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsAllDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_team_drives {
-            write!(f, "&supportsTeamDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsTeamDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -2697,28 +3085,60 @@
 impl std::fmt::Display for PermissionsCreateParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.email_message {
-            write!(f, "&emailMessage={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&emailMessage={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.enforce_single_parent {
-            write!(f, "&enforceSingleParent={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&enforceSingleParent={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.move_to_new_owners_root {
-            write!(f, "&moveToNewOwnersRoot={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&moveToNewOwnersRoot={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.send_notification_email {
-            write!(f, "&sendNotificationEmail={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&sendNotificationEmail={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_all_drives {
-            write!(f, "&supportsAllDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsAllDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_team_drives {
-            write!(f, "&supportsTeamDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsTeamDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.transfer_ownership {
-            write!(f, "&transferOwnership={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&transferOwnership={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.use_domain_admin_access {
-            write!(f, "&useDomainAdminAccess={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&useDomainAdminAccess={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -2750,13 +3170,25 @@
 impl std::fmt::Display for PermissionsDeleteParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.supports_all_drives {
-            write!(f, "&supportsAllDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsAllDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_team_drives {
-            write!(f, "&supportsTeamDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsTeamDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.use_domain_admin_access {
-            write!(f, "&useDomainAdminAccess={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&useDomainAdminAccess={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -2788,13 +3220,25 @@
 impl std::fmt::Display for PermissionsGetParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.supports_all_drives {
-            write!(f, "&supportsAllDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsAllDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_team_drives {
-            write!(f, "&supportsTeamDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsTeamDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.use_domain_admin_access {
-            write!(f, "&useDomainAdminAccess={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&useDomainAdminAccess={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -2832,22 +3276,46 @@
 impl std::fmt::Display for PermissionsListParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.include_permissions_for_view {
-            write!(f, "&includePermissionsForView={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&includePermissionsForView={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.page_size {
-            write!(f, "&pageSize={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&pageSize={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.page_token {
-            write!(f, "&pageToken={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&pageToken={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_all_drives {
-            write!(f, "&supportsAllDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsAllDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_team_drives {
-            write!(f, "&supportsTeamDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsTeamDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.use_domain_admin_access {
-            write!(f, "&useDomainAdminAccess={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&useDomainAdminAccess={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -2885,19 +3353,39 @@
 impl std::fmt::Display for PermissionsUpdateParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.remove_expiration {
-            write!(f, "&removeExpiration={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&removeExpiration={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_all_drives {
-            write!(f, "&supportsAllDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsAllDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.supports_team_drives {
-            write!(f, "&supportsTeamDrives={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&supportsTeamDrives={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.transfer_ownership {
-            write!(f, "&transferOwnership={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&transferOwnership={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.use_domain_admin_access {
-            write!(f, "&useDomainAdminAccess={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&useDomainAdminAccess={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -2969,7 +3457,11 @@
 impl std::fmt::Display for RepliesGetParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.include_deleted {
-            write!(f, "&includeDeleted={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&includeDeleted={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -3001,13 +3493,25 @@
 impl std::fmt::Display for RepliesListParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.include_deleted {
-            write!(f, "&includeDeleted={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&includeDeleted={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.page_size {
-            write!(f, "&pageSize={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&pageSize={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.page_token {
-            write!(f, "&pageToken={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&pageToken={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -3076,7 +3580,11 @@
 impl std::fmt::Display for RevisionsGetParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.acknowledge_abuse {
-            write!(f, "&acknowledgeAbuse={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&acknowledgeAbuse={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -3102,10 +3610,18 @@
 impl std::fmt::Display for RevisionsListParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.page_size {
-            write!(f, "&pageSize={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&pageSize={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.page_token {
-            write!(f, "&pageToken={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&pageToken={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -3144,7 +3660,11 @@
 
 impl std::fmt::Display for TeamdrivesCreateParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "&requestId={}", percent_encode(format!("{}", self.request_id).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+        write!(
+            f,
+            "&requestId={}",
+            percent_encode(format!("{}", self.request_id).as_bytes(), NON_ALPHANUMERIC).to_string()
+        )?;
         Ok(())
     }
 }
@@ -3183,7 +3703,11 @@
 impl std::fmt::Display for TeamdrivesGetParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.use_domain_admin_access {
-            write!(f, "&useDomainAdminAccess={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&useDomainAdminAccess={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -3212,16 +3736,32 @@
 impl std::fmt::Display for TeamdrivesListParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.page_size {
-            write!(f, "&pageSize={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&pageSize={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.page_token {
-            write!(f, "&pageToken={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&pageToken={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.q {
-            write!(f, "&q={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&q={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.use_domain_admin_access {
-            write!(f, "&useDomainAdminAccess={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&useDomainAdminAccess={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -3244,7 +3784,11 @@
 impl std::fmt::Display for TeamdrivesUpdateParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.use_domain_admin_access {
-            write!(f, "&useDomainAdminAccess={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&useDomainAdminAccess={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -3253,25 +3797,53 @@
 impl std::fmt::Display for DriveParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(ref v) = self.alt {
-            write!(f, "&alt={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&alt={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.fields {
-            write!(f, "&fields={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&fields={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.key {
-            write!(f, "&key={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&key={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.oauth_token {
-            write!(f, "&oauth_token={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&oauth_token={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.pretty_print {
-            write!(f, "&prettyPrint={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&prettyPrint={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.quota_user {
-            write!(f, "&quotaUser={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&quotaUser={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         if let Some(ref v) = self.user_ip {
-            write!(f, "&userIp={}", percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string())?;
+            write!(
+                f,
+                "&userIp={}",
+                percent_encode(format!("{}", v).as_bytes(), NON_ALPHANUMERIC).to_string()
+            )?;
         }
         Ok(())
     }
@@ -3280,7 +3852,7 @@
 /// The Drive About service represents the About resource.
 pub struct AboutService {
     client: TlsClient,
-    authenticator: Box<dyn 'static + std::ops::Deref<Target=Authenticator>>,
+    authenticator: Box<dyn 'static + std::ops::Deref<Target = Authenticator>>,
     scopes: Vec<String>,
 }
 
@@ -3288,8 +3860,15 @@
     /// Create a new AboutService object. The easiest way to call this is wrapping the Authenticator
     /// into an `Rc`: `new(client.clone(), Rc::new(authenticator))`.
     /// This way, one authenticator can be shared among several services.
-    pub fn new<A: 'static + std::ops::Deref<Target=Authenticator>>(client: TlsClient, auth: A) -> AboutService {
-        AboutService { client: client, authenticator: Box::new(auth), scopes: vec![] }
+    pub fn new<A: 'static + std::ops::Deref<Target = Authenticator>>(
+        client: TlsClient,
+        auth: A,
+    ) -> AboutService {
+        AboutService {
+            client: client,
+            authenticator: Box::new(auth),
+            scopes: vec![],
+        }
     }
 
     /// Explicitly select which scopes should be requested for authorization. Otherwise,
@@ -3297,43 +3876,50 @@
     ///
     /// It is most convenient to supply a vec or slice of DriveScopes enum values.
     pub fn set_scopes<S: AsRef<str>, T: AsRef<[S]>>(&mut self, scopes: T) {
-        self.scopes = scopes.as_ref().into_iter().map(|s| s.as_ref().to_string()).collect();
+        self.scopes = scopes
+            .as_ref()
+            .into_iter()
+            .map(|s| s.as_ref().to_string())
+            .collect();
     }
 
-
-/// Gets information about the user, the user's Drive, and system capabilities.
-pub async fn get(
-    &mut self, params: &AboutGetParams) -> Result<About> {
-
-    let rel_path = format!("about", );
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
+    /// Gets information about the user, the user's Drive, and system capabilities.
+    pub async fn get(&mut self, params: &AboutGetParams) -> Result<About> {
+        let rel_path = format!("about",);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "GET",
+            opt_request,
+        )
+        .await
     }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
-    }
-
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "GET", opt_request).await
-  }
-
 }
 
 /// The Drive Changes service represents the Changes resource.
 pub struct ChangesService {
     client: TlsClient,
-    authenticator: Box<dyn 'static + std::ops::Deref<Target=Authenticator>>,
+    authenticator: Box<dyn 'static + std::ops::Deref<Target = Authenticator>>,
     scopes: Vec<String>,
 }
 
@@ -3341,8 +3927,15 @@
     /// Create a new ChangesService object. The easiest way to call this is wrapping the Authenticator
     /// into an `Rc`: `new(client.clone(), Rc::new(authenticator))`.
     /// This way, one authenticator can be shared among several services.
-    pub fn new<A: 'static + std::ops::Deref<Target=Authenticator>>(client: TlsClient, auth: A) -> ChangesService {
-        ChangesService { client: client, authenticator: Box::new(auth), scopes: vec![] }
+    pub fn new<A: 'static + std::ops::Deref<Target = Authenticator>>(
+        client: TlsClient,
+        auth: A,
+    ) -> ChangesService {
+        ChangesService {
+            client: client,
+            authenticator: Box::new(auth),
+            scopes: vec![],
+        }
     }
 
     /// Explicitly select which scopes should be requested for authorization. Otherwise,
@@ -3350,100 +3943,118 @@
     ///
     /// It is most convenient to supply a vec or slice of DriveScopes enum values.
     pub fn set_scopes<S: AsRef<str>, T: AsRef<[S]>>(&mut self, scopes: T) {
-        self.scopes = scopes.as_ref().into_iter().map(|s| s.as_ref().to_string()).collect();
+        self.scopes = scopes
+            .as_ref()
+            .into_iter()
+            .map(|s| s.as_ref().to_string())
+            .collect();
     }
 
-
-/// Gets the starting pageToken for listing future changes.
-pub async fn get_start_page_token(
-    &mut self, params: &ChangesGetStartPageTokenParams) -> Result<StartPageToken> {
-
-    let rel_path = format!("changes/startPageToken", );
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Gets the starting pageToken for listing future changes.
+    pub async fn get_start_page_token(
+        &mut self,
+        params: &ChangesGetStartPageTokenParams,
+    ) -> Result<StartPageToken> {
+        let rel_path = format!("changes/startPageToken",);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "GET",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "GET", opt_request).await
-  }
-
-
-/// Lists the changes for a user or shared drive.
-pub async fn list(
-    &mut self, params: &ChangesListParams) -> Result<ChangeList> {
-
-    let rel_path = format!("changes", );
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Lists the changes for a user or shared drive.
+    pub async fn list(&mut self, params: &ChangesListParams) -> Result<ChangeList> {
+        let rel_path = format!("changes",);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "GET",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "GET", opt_request).await
-  }
-
-
-/// Subscribes to changes for a user.
-pub async fn watch(
-    &mut self, params: &ChangesWatchParams, req: &Channel) -> Result<Channel> {
-
-    let rel_path = format!("changes/watch", );
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
+    /// Subscribes to changes for a user.
+    pub async fn watch(&mut self, params: &ChangesWatchParams, req: &Channel) -> Result<Channel> {
+        let rel_path = format!("changes/watch",);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        let opt_request = Some(req);
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "POST",
+            opt_request,
+        )
+        .await
     }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
-    }
-
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    let opt_request = Some(req);
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "POST", opt_request).await
-  }
-
 }
 
 /// The Drive Channels service represents the Channels resource.
 pub struct ChannelsService {
     client: TlsClient,
-    authenticator: Box<dyn 'static + std::ops::Deref<Target=Authenticator>>,
+    authenticator: Box<dyn 'static + std::ops::Deref<Target = Authenticator>>,
     scopes: Vec<String>,
 }
 
@@ -3451,8 +4062,15 @@
     /// Create a new ChannelsService object. The easiest way to call this is wrapping the Authenticator
     /// into an `Rc`: `new(client.clone(), Rc::new(authenticator))`.
     /// This way, one authenticator can be shared among several services.
-    pub fn new<A: 'static + std::ops::Deref<Target=Authenticator>>(client: TlsClient, auth: A) -> ChannelsService {
-        ChannelsService { client: client, authenticator: Box::new(auth), scopes: vec![] }
+    pub fn new<A: 'static + std::ops::Deref<Target = Authenticator>>(
+        client: TlsClient,
+        auth: A,
+    ) -> ChannelsService {
+        ChannelsService {
+            client: client,
+            authenticator: Box::new(auth),
+            scopes: vec![],
+        }
     }
 
     /// Explicitly select which scopes should be requested for authorization. Otherwise,
@@ -3460,44 +4078,51 @@
     ///
     /// It is most convenient to supply a vec or slice of DriveScopes enum values.
     pub fn set_scopes<S: AsRef<str>, T: AsRef<[S]>>(&mut self, scopes: T) {
-        self.scopes = scopes.as_ref().into_iter().map(|s| s.as_ref().to_string()).collect();
+        self.scopes = scopes
+            .as_ref()
+            .into_iter()
+            .map(|s| s.as_ref().to_string())
+            .collect();
     }
 
-
-/// Stop watching resources through this channel
-pub async fn stop(
-    &mut self, params: &ChannelsStopParams, req: &Channel) -> Result<()> {
-
-    let rel_path = format!("channels/stop", );
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
+    /// Stop watching resources through this channel
+    pub async fn stop(&mut self, params: &ChannelsStopParams, req: &Channel) -> Result<()> {
+        let rel_path = format!("channels/stop",);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        let opt_request = Some(req);
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "POST",
+            opt_request,
+        )
+        .await
     }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
-    }
-
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    let opt_request = Some(req);
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "POST", opt_request).await
-  }
-
 }
 
 /// The Drive Comments service represents the Comments resource.
 pub struct CommentsService {
     client: TlsClient,
-    authenticator: Box<dyn 'static + std::ops::Deref<Target=Authenticator>>,
+    authenticator: Box<dyn 'static + std::ops::Deref<Target = Authenticator>>,
     scopes: Vec<String>,
 }
 
@@ -3505,8 +4130,15 @@
     /// Create a new CommentsService object. The easiest way to call this is wrapping the Authenticator
     /// into an `Rc`: `new(client.clone(), Rc::new(authenticator))`.
     /// This way, one authenticator can be shared among several services.
-    pub fn new<A: 'static + std::ops::Deref<Target=Authenticator>>(client: TlsClient, auth: A) -> CommentsService {
-        CommentsService { client: client, authenticator: Box::new(auth), scopes: vec![] }
+    pub fn new<A: 'static + std::ops::Deref<Target = Authenticator>>(
+        client: TlsClient,
+        auth: A,
+    ) -> CommentsService {
+        CommentsService {
+            client: client,
+            authenticator: Box::new(auth),
+            scopes: vec![],
+        }
     }
 
     /// Explicitly select which scopes should be requested for authorization. Otherwise,
@@ -3514,157 +4146,200 @@
     ///
     /// It is most convenient to supply a vec or slice of DriveScopes enum values.
     pub fn set_scopes<S: AsRef<str>, T: AsRef<[S]>>(&mut self, scopes: T) {
-        self.scopes = scopes.as_ref().into_iter().map(|s| s.as_ref().to_string()).collect();
-    }
-
-
-/// Creates a new comment on a file.
-pub async fn create(
-    &mut self, params: &CommentsCreateParams, req: &Comment) -> Result<Comment> {
-
-    let rel_path = format!("files/{fileId}/comments", fileId=params.file_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.file".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+        self.scopes = scopes
+            .as_ref()
+            .into_iter()
+            .map(|s| s.as_ref().to_string())
+            .collect();
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    let opt_request = Some(req);
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "POST", opt_request).await
-  }
-
-
-/// Deletes a comment.
-pub async fn delete(
-    &mut self, params: &CommentsDeleteParams) -> Result<()> {
-
-    let rel_path = format!("files/{fileId}/comments/{commentId}", fileId=params.file_id,commentId=params.comment_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.file".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
+    /// Creates a new comment on a file.
+    pub async fn create(
+        &mut self,
+        params: &CommentsCreateParams,
+        req: &Comment,
+    ) -> Result<Comment> {
+        let rel_path = format!("files/{fileId}/comments", fileId = params.file_id);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.file".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        let opt_request = Some(req);
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "POST",
+            opt_request,
+        )
+        .await
     }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+
+    /// Deletes a comment.
+    pub async fn delete(&mut self, params: &CommentsDeleteParams) -> Result<()> {
+        let rel_path = format!(
+            "files/{fileId}/comments/{commentId}",
+            fileId = params.file_id,
+            commentId = params.comment_id
+        );
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.file".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "DELETE",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "DELETE", opt_request).await
-  }
-
-
-/// Gets a comment by ID.
-pub async fn get(
-    &mut self, params: &CommentsGetParams) -> Result<Comment> {
-
-    let rel_path = format!("files/{fileId}/comments/{commentId}", fileId=params.file_id,commentId=params.comment_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Gets a comment by ID.
+    pub async fn get(&mut self, params: &CommentsGetParams) -> Result<Comment> {
+        let rel_path = format!(
+            "files/{fileId}/comments/{commentId}",
+            fileId = params.file_id,
+            commentId = params.comment_id
+        );
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "GET",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "GET", opt_request).await
-  }
-
-
-/// Lists a file's comments.
-pub async fn list(
-    &mut self, params: &CommentsListParams) -> Result<CommentList> {
-
-    let rel_path = format!("files/{fileId}/comments", fileId=params.file_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Lists a file's comments.
+    pub async fn list(&mut self, params: &CommentsListParams) -> Result<CommentList> {
+        let rel_path = format!("files/{fileId}/comments", fileId = params.file_id);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "GET",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "GET", opt_request).await
-  }
-
-
-/// Updates a comment with patch semantics.
-pub async fn update(
-    &mut self, params: &CommentsUpdateParams, req: &Comment) -> Result<Comment> {
-
-    let rel_path = format!("files/{fileId}/comments/{commentId}", fileId=params.file_id,commentId=params.comment_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.file".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
+    /// Updates a comment with patch semantics.
+    pub async fn update(
+        &mut self,
+        params: &CommentsUpdateParams,
+        req: &Comment,
+    ) -> Result<Comment> {
+        let rel_path = format!(
+            "files/{fileId}/comments/{commentId}",
+            fileId = params.file_id,
+            commentId = params.comment_id
+        );
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.file".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        let opt_request = Some(req);
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "PATCH",
+            opt_request,
+        )
+        .await
     }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
-    }
-
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    let opt_request = Some(req);
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "PATCH", opt_request).await
-  }
-
 }
 
 /// The Drive Drives service represents the Drives resource.
 pub struct DrivesService {
     client: TlsClient,
-    authenticator: Box<dyn 'static + std::ops::Deref<Target=Authenticator>>,
+    authenticator: Box<dyn 'static + std::ops::Deref<Target = Authenticator>>,
     scopes: Vec<String>,
 }
 
@@ -3672,8 +4347,15 @@
     /// Create a new DrivesService object. The easiest way to call this is wrapping the Authenticator
     /// into an `Rc`: `new(client.clone(), Rc::new(authenticator))`.
     /// This way, one authenticator can be shared among several services.
-    pub fn new<A: 'static + std::ops::Deref<Target=Authenticator>>(client: TlsClient, auth: A) -> DrivesService {
-        DrivesService { client: client, authenticator: Box::new(auth), scopes: vec![] }
+    pub fn new<A: 'static + std::ops::Deref<Target = Authenticator>>(
+        client: TlsClient,
+        auth: A,
+    ) -> DrivesService {
+        DrivesService {
+            client: client,
+            authenticator: Box::new(auth),
+            scopes: vec![],
+        }
     }
 
     /// Explicitly select which scopes should be requested for authorization. Otherwise,
@@ -3681,213 +4363,244 @@
     ///
     /// It is most convenient to supply a vec or slice of DriveScopes enum values.
     pub fn set_scopes<S: AsRef<str>, T: AsRef<[S]>>(&mut self, scopes: T) {
-        self.scopes = scopes.as_ref().into_iter().map(|s| s.as_ref().to_string()).collect();
+        self.scopes = scopes
+            .as_ref()
+            .into_iter()
+            .map(|s| s.as_ref().to_string())
+            .collect();
     }
 
-
-/// Creates a new shared drive.
-pub async fn create(
-    &mut self, params: &DrivesCreateParams, req: &Drive) -> Result<Drive> {
-
-    let rel_path = format!("drives", );
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Creates a new shared drive.
+    pub async fn create(&mut self, params: &DrivesCreateParams, req: &Drive) -> Result<Drive> {
+        let rel_path = format!("drives",);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        let opt_request = Some(req);
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "POST",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    let opt_request = Some(req);
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "POST", opt_request).await
-  }
-
-
-/// Permanently deletes a shared drive for which the user is an organizer. The shared drive cannot contain any untrashed items.
-pub async fn delete(
-    &mut self, params: &DrivesDeleteParams) -> Result<()> {
-
-    let rel_path = format!("drives/{driveId}", driveId=params.drive_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Permanently deletes a shared drive for which the user is an organizer. The shared drive cannot contain any untrashed items.
+    pub async fn delete(&mut self, params: &DrivesDeleteParams) -> Result<()> {
+        let rel_path = format!("drives/{driveId}", driveId = params.drive_id);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "DELETE",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "DELETE", opt_request).await
-  }
-
-
-/// Gets a shared drive's metadata by ID.
-pub async fn get(
-    &mut self, params: &DrivesGetParams) -> Result<Drive> {
-
-    let rel_path = format!("drives/{driveId}", driveId=params.drive_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Gets a shared drive's metadata by ID.
+    pub async fn get(&mut self, params: &DrivesGetParams) -> Result<Drive> {
+        let rel_path = format!("drives/{driveId}", driveId = params.drive_id);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "GET",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "GET", opt_request).await
-  }
-
-
-/// Hides a shared drive from the default view.
-pub async fn hide(
-    &mut self, params: &DrivesHideParams) -> Result<Drive> {
-
-    let rel_path = format!("drives/{driveId}/hide", driveId=params.drive_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Hides a shared drive from the default view.
+    pub async fn hide(&mut self, params: &DrivesHideParams) -> Result<Drive> {
+        let rel_path = format!("drives/{driveId}/hide", driveId = params.drive_id);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "POST",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "POST", opt_request).await
-  }
-
-
-/// Lists the user's shared drives.
-pub async fn list(
-    &mut self, params: &DrivesListParams) -> Result<DriveList> {
-
-    let rel_path = format!("drives", );
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Lists the user's shared drives.
+    pub async fn list(&mut self, params: &DrivesListParams) -> Result<DriveList> {
+        let rel_path = format!("drives",);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "GET",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "GET", opt_request).await
-  }
-
-
-/// Restores a shared drive to the default view.
-pub async fn unhide(
-    &mut self, params: &DrivesUnhideParams) -> Result<Drive> {
-
-    let rel_path = format!("drives/{driveId}/unhide", driveId=params.drive_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Restores a shared drive to the default view.
+    pub async fn unhide(&mut self, params: &DrivesUnhideParams) -> Result<Drive> {
+        let rel_path = format!("drives/{driveId}/unhide", driveId = params.drive_id);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "POST",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "POST", opt_request).await
-  }
-
-
-/// Updates the metadate for a shared drive.
-pub async fn update(
-    &mut self, params: &DrivesUpdateParams, req: &Drive) -> Result<Drive> {
-
-    let rel_path = format!("drives/{driveId}", driveId=params.drive_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
+    /// Updates the metadate for a shared drive.
+    pub async fn update(&mut self, params: &DrivesUpdateParams, req: &Drive) -> Result<Drive> {
+        let rel_path = format!("drives/{driveId}", driveId = params.drive_id);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        let opt_request = Some(req);
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "PATCH",
+            opt_request,
+        )
+        .await
     }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
-    }
-
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    let opt_request = Some(req);
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "PATCH", opt_request).await
-  }
-
 }
 
 /// The Drive Files service represents the Files resource.
 pub struct FilesService {
     client: TlsClient,
-    authenticator: Box<dyn 'static + std::ops::Deref<Target=Authenticator>>,
+    authenticator: Box<dyn 'static + std::ops::Deref<Target = Authenticator>>,
     scopes: Vec<String>,
 }
 
@@ -3895,8 +4608,15 @@
     /// Create a new FilesService object. The easiest way to call this is wrapping the Authenticator
     /// into an `Rc`: `new(client.clone(), Rc::new(authenticator))`.
     /// This way, one authenticator can be shared among several services.
-    pub fn new<A: 'static + std::ops::Deref<Target=Authenticator>>(client: TlsClient, auth: A) -> FilesService {
-        FilesService { client: client, authenticator: Box::new(auth), scopes: vec![] }
+    pub fn new<A: 'static + std::ops::Deref<Target = Authenticator>>(
+        client: TlsClient,
+        auth: A,
+    ) -> FilesService {
+        FilesService {
+            client: client,
+            authenticator: Box::new(auth),
+            scopes: vec![],
+        }
     }
 
     /// Explicitly select which scopes should be requested for authorization. Otherwise,
@@ -3904,449 +4624,577 @@
     ///
     /// It is most convenient to supply a vec or slice of DriveScopes enum values.
     pub fn set_scopes<S: AsRef<str>, T: AsRef<[S]>>(&mut self, scopes: T) {
-        self.scopes = scopes.as_ref().into_iter().map(|s| s.as_ref().to_string()).collect();
+        self.scopes = scopes
+            .as_ref()
+            .into_iter()
+            .map(|s| s.as_ref().to_string())
+            .collect();
     }
 
-
-/// Creates a copy of a file and applies any requested updates with patch semantics. Folders cannot be copied.
-pub async fn copy(
-    &mut self, params: &FilesCopyParams, req: &File) -> Result<File> {
-
-    let rel_path = format!("files/{fileId}/copy", fileId=params.file_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.photos.readonly".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Creates a copy of a file and applies any requested updates with patch semantics. Folders cannot be copied.
+    pub async fn copy(&mut self, params: &FilesCopyParams, req: &File) -> Result<File> {
+        let rel_path = format!("files/{fileId}/copy", fileId = params.file_id);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.photos.readonly".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        let opt_request = Some(req);
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "POST",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    let opt_request = Some(req);
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "POST", opt_request).await
-  }
-
-
-/// Creates a new file.
-pub async fn create(
-    &mut self, params: &FilesCreateParams, req: &File) -> Result<File> {
-
-    let rel_path = format!("files", );
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.file".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Creates a new file.
+    pub async fn create(&mut self, params: &FilesCreateParams, req: &File) -> Result<File> {
+        let rel_path = format!("files",);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.file".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        let opt_request = Some(req);
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "POST",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    let opt_request = Some(req);
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "POST", opt_request).await
-  }
-
-
-/// Creates a new file.
-///
-/// This method is a variant of `create()`, taking data for upload. It performs a multipart upload.
-pub async fn create_upload(
-    &mut self, params: &FilesCreateParams, req: &File, data: hyper::body::Bytes) -> Result<File> {
-    let rel_path = "upload/drive/v3/files";
-    let path = "https://www.googleapis.com/".to_string() + &rel_path;
-
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.file".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?uploadType=multipart{params}", params=params);
-
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Creates a new file.
+    ///
+    /// This method is a variant of `create()`, taking data for upload. It performs a multipart upload.
+    pub async fn create_upload(
+        &mut self,
+        params: &FilesCreateParams,
+        req: &File,
+        data: hyper::body::Bytes,
+    ) -> Result<File> {
+        let rel_path = format!("/upload/drive/v3/files",);
+        let path = "https://www.googleapis.com/".to_string() + &rel_path;
+
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.file".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?uploadType=multipart{params}", params = params);
+
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+        let opt_request: Option<EmptyRequest> = None;
+        let opt_request = Some(req);
+
+        do_upload_multipart(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "POST",
+            opt_request,
+            data,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-    let opt_request: Option<EmptyRequest> = None;
-    let opt_request = Some(req);
-
-    do_upload_multipart(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "POST", opt_request, data).await
-  }
-
-
-/// Creates a new file.
-///
-/// This method is a variant of `create()`, taking data for upload.
-/// It returns a `ResumableUpload` upload manager which you can use to stream larger amounts
-/// of data to the API. The result of this call will be returned by the `ResumableUpload` method
-/// you choose for the upload.
-pub async fn create_resumable_upload<'client>(
-    &'client mut self, params: &FilesCreateParams, req: &File) -> Result<ResumableUpload<'client, File>> {
-
-    let rel_path = "resumable/upload/drive/v3/files";
-    let path = "https://www.googleapis.com/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.file".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?uploadType=resumable{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
-    }
-
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    let opt_request = Some(req);
-    let (_resp, headers): (EmptyResponse, hyper::HeaderMap) = do_request_with_headers(
-        &self.client, &full_uri, &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))], "POST", opt_request).await?;
-    if let Some(dest) = headers.get(hyper::header::LOCATION) {
-        use std::convert::TryFrom;
-        Ok(ResumableUpload::new(hyper::Uri::try_from(dest.to_str()?)?, &self.client, 5*1024*1024))
-    } else {
-        Err(Error::from(ApiError::RedirectError(format!("Resumable upload response didn't contain Location: {:?}", headers)))
-        .context(format!("{:?}", headers)))?
+    /// Creates a new file.
+    ///
+    /// This method is a variant of `create()`, taking data for upload.
+    /// It returns a `ResumableUpload` upload manager which you can use to stream larger amounts
+    /// of data to the API. The result of this call will be returned by the `ResumableUpload` method
+    /// you choose for the upload.
+    pub async fn create_resumable_upload<'client>(
+        &'client mut self,
+        params: &FilesCreateParams,
+        req: &File,
+    ) -> Result<ResumableUpload<'client, File>> {
+        let rel_path = format!("/resumable/upload/drive/v3/files",);
+        let path = "https://www.googleapis.com/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.file".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?uploadType=resumable{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        let opt_request = Some(req);
+        let (_resp, headers): (EmptyResponse, hyper::HeaderMap) = do_request_with_headers(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "POST",
+            opt_request,
+        )
+        .await?;
+        if let Some(dest) = headers.get(hyper::header::LOCATION) {
+            use std::convert::TryFrom;
+            Ok(ResumableUpload::new(
+                hyper::Uri::try_from(dest.to_str()?)?,
+                &self.client,
+                5 * 1024 * 1024,
+            ))
+        } else {
+            Err(Error::from(ApiError::RedirectError(format!(
+                "Resumable upload response didn't contain Location: {:?}",
+                headers
+            )))
+            .context(format!("{:?}", headers)))?
+        }
     }
-  }
-
-
-/// Permanently deletes a file owned by the user without moving it to the trash. If the file belongs to a shared drive the user must be an organizer on the parent. If the target is a folder, all descendants owned by the user are also deleted.
-pub async fn delete(
-    &mut self, params: &FilesDeleteParams) -> Result<()> {
-
-    let rel_path = format!("files/{fileId}", fileId=params.file_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.file".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+
+    /// Permanently deletes a file owned by the user without moving it to the trash. If the file belongs to a shared drive the user must be an organizer on the parent. If the target is a folder, all descendants owned by the user are also deleted.
+    pub async fn delete(&mut self, params: &FilesDeleteParams) -> Result<()> {
+        let rel_path = format!("files/{fileId}", fileId = params.file_id);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.file".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "DELETE",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "DELETE", opt_request).await
-  }
-
-
-/// Permanently deletes all of the user's trashed files.
-pub async fn empty_trash(
-    &mut self, params: &FilesEmptyTrashParams) -> Result<()> {
-
-    let rel_path = format!("files/trash", );
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Permanently deletes all of the user's trashed files.
+    pub async fn empty_trash(&mut self, params: &FilesEmptyTrashParams) -> Result<()> {
+        let rel_path = format!("files/trash",);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "DELETE",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "DELETE", opt_request).await
-  }
-
-
-/// Exports a Google Doc to the requested MIME type and returns the exported content. Please note that the exported content is limited to 10MB.
-pub async fn export(
-    &mut self, params: &FilesExportParams) -> Result<()> {
-
-    let rel_path = format!("files/{fileId}/export", fileId=params.file_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Exports a Google Doc to the requested MIME type and returns the exported content. Please note that the exported content is limited to 10MB.
+    ///
+    /// This method downloads data. Depending on the server returning a `Content-Type` of `application/json`
+    /// or a non-JSON type, the returned value indicates if a download took place or data was written to
+    /// `dst`. If `dst` is `None` despite data being available for download, `ApiError::DataAvailableError`
+    /// is returned.
+    pub async fn export(
+        &mut self,
+        params: &FilesExportParams,
+        dst: Option<&mut dyn std::io::Write>,
+    ) -> Result<DownloadResponse<()>> {
+        let rel_path = format!("files/{fileId}/export", fileId = params.file_id);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+        let opt_request: Option<EmptyRequest> = None;
+
+        do_download(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "GET",
+            opt_request,
+            dst,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "GET", opt_request).await
-  }
-
-
-/// Generates a set of file IDs which can be provided in create or copy requests.
-pub async fn generate_ids(
-    &mut self, params: &FilesGenerateIdsParams) -> Result<GeneratedIds> {
-
-    let rel_path = format!("files/generateIds", );
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.file".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
-    }
-
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "GET", opt_request).await
-  }
-
-
-/// Gets a file's metadata or content by ID.
-///
-/// This method downloads data.
-pub async fn get(
-    &mut self, params: &FilesGetParams,  dst: Option<&mut dyn std::io::Write>)
-    -> Result<DownloadResponse<File>> {
-
-    let rel_path = format!("files/{fileId}", fileId=params.file_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
+    /// Generates a set of file IDs which can be provided in create or copy requests.
+    pub async fn generate_ids(&mut self, params: &FilesGenerateIdsParams) -> Result<GeneratedIds> {
+        let rel_path = format!("files/generateIds",);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.file".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "GET",
+            opt_request,
+        )
+        .await
     }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
-    }
-
-    let full_uri = path + &url_params;
-    let opt_request: Option<EmptyRequest> = None;
-
-    do_download(&self.client, &full_uri, &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "GET", opt_request, dst).await
-  }
-
-
-/// Lists or searches files.
-pub async fn list(
-    &mut self, params: &FilesListParams) -> Result<FileList> {
-
-    let rel_path = format!("files", );
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
+
+    /// Gets a file's metadata or content by ID.
+    ///
+    /// This method downloads data. Depending on the server returning a `Content-Type` of `application/json`
+    /// or a non-JSON type, the returned value indicates if a download took place or data was written to
+    /// `dst`. If `dst` is `None` despite data being available for download, `ApiError::DataAvailableError`
+    /// is returned.
+    pub async fn get(
+        &mut self,
+        params: &FilesGetParams,
+        dst: Option<&mut dyn std::io::Write>,
+    ) -> Result<DownloadResponse<File>> {
+        let rel_path = format!("files/{fileId}", fileId = params.file_id);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+        let opt_request: Option<EmptyRequest> = None;
+
+        do_download(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "GET",
+            opt_request,
+            dst,
+        )
+        .await
     }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+
+    /// Lists or searches files.
+    pub async fn list(&mut self, params: &FilesListParams) -> Result<FileList> {
+        let rel_path = format!("files",);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "GET",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "GET", opt_request).await
-  }
-
-
-/// Updates a file's metadata and/or content. This method supports patch semantics.
-pub async fn update(
-    &mut self, params: &FilesUpdateParams, req: &File) -> Result<File> {
-
-    let rel_path = format!("files/{fileId}", fileId=params.file_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.scripts".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Updates a file's metadata and/or content. This method supports patch semantics.
+    pub async fn update(&mut self, params: &FilesUpdateParams, req: &File) -> Result<File> {
+        let rel_path = format!("files/{fileId}", fileId = params.file_id);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.scripts".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        let opt_request = Some(req);
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "PATCH",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    let opt_request = Some(req);
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "PATCH", opt_request).await
-  }
-
-
-/// Updates a file's metadata and/or content. This method supports patch semantics.
-///
-/// This method is a variant of `update()`, taking data for upload. It performs a multipart upload.
-pub async fn update_upload(
-    &mut self, params: &FilesUpdateParams, req: &File, data: hyper::body::Bytes) -> Result<File> {
-    let rel_path = "upload/drive/v3/files/{fileId}";
-    let path = "https://www.googleapis.com/".to_string() + &rel_path;
-
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.scripts".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?uploadType=multipart{params}", params=params);
-
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Updates a file's metadata and/or content. This method supports patch semantics.
+    ///
+    /// This method is a variant of `update()`, taking data for upload. It performs a multipart upload.
+    pub async fn update_upload(
+        &mut self,
+        params: &FilesUpdateParams,
+        req: &File,
+        data: hyper::body::Bytes,
+    ) -> Result<File> {
+        let rel_path = format!("/upload/drive/v3/files/{fileId}", fileId = params.file_id);
+        let path = "https://www.googleapis.com/".to_string() + &rel_path;
+
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.scripts".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?uploadType=multipart{params}", params = params);
+
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+        let opt_request: Option<EmptyRequest> = None;
+        let opt_request = Some(req);
+
+        do_upload_multipart(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "PATCH",
+            opt_request,
+            data,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-    let opt_request: Option<EmptyRequest> = None;
-    let opt_request = Some(req);
-
-    do_upload_multipart(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "PATCH", opt_request, data).await
-  }
-
-
-/// Updates a file's metadata and/or content. This method supports patch semantics.
-///
-/// This method is a variant of `update()`, taking data for upload.
-/// It returns a `ResumableUpload` upload manager which you can use to stream larger amounts
-/// of data to the API. The result of this call will be returned by the `ResumableUpload` method
-/// you choose for the upload.
-pub async fn update_resumable_upload<'client>(
-    &'client mut self, params: &FilesUpdateParams, req: &File) -> Result<ResumableUpload<'client, File>> {
-
-    let rel_path = "resumable/upload/drive/v3/files/{fileId}";
-    let path = "https://www.googleapis.com/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.scripts".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?uploadType=resumable{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Updates a file's metadata and/or content. This method supports patch semantics.
+    ///
+    /// This method is a variant of `update()`, taking data for upload.
+    /// It returns a `ResumableUpload` upload manager which you can use to stream larger amounts
+    /// of data to the API. The result of this call will be returned by the `ResumableUpload` method
+    /// you choose for the upload.
+    pub async fn update_resumable_upload<'client>(
+        &'client mut self,
+        params: &FilesUpdateParams,
+        req: &File,
+    ) -> Result<ResumableUpload<'client, File>> {
+        let rel_path = format!(
+            "/resumable/upload/drive/v3/files/{fileId}",
+            fileId = params.file_id
+        );
+        let path = "https://www.googleapis.com/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.scripts".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?uploadType=resumable{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        let opt_request = Some(req);
+        let (_resp, headers): (EmptyResponse, hyper::HeaderMap) = do_request_with_headers(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "PATCH",
+            opt_request,
+        )
+        .await?;
+        if let Some(dest) = headers.get(hyper::header::LOCATION) {
+            use std::convert::TryFrom;
+            Ok(ResumableUpload::new(
+                hyper::Uri::try_from(dest.to_str()?)?,
+                &self.client,
+                5 * 1024 * 1024,
+            ))
+        } else {
+            Err(Error::from(ApiError::RedirectError(format!(
+                "Resumable upload response didn't contain Location: {:?}",
+                headers
+            )))
+            .context(format!("{:?}", headers)))?
+        }
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    let opt_request = Some(req);
-    let (_resp, headers): (EmptyResponse, hyper::HeaderMap) = do_request_with_headers(
-        &self.client, &full_uri, &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))], "PATCH", opt_request).await?;
-    if let Some(dest) = headers.get(hyper::header::LOCATION) {
-        use std::convert::TryFrom;
-        Ok(ResumableUpload::new(hyper::Uri::try_from(dest.to_str()?)?, &self.client, 5*1024*1024))
-    } else {
-        Err(Error::from(ApiError::RedirectError(format!("Resumable upload response didn't contain Location: {:?}", headers)))
-        .context(format!("{:?}", headers)))?
+    /// Subscribes to changes to a file
+    ///
+    /// This method downloads data. Depending on the server returning a `Content-Type` of `application/json`
+    /// or a non-JSON type, the returned value indicates if a download took place or data was written to
+    /// `dst`. If `dst` is `None` despite data being available for download, `ApiError::DataAvailableError`
+    /// is returned.
+    pub async fn watch(
+        &mut self,
+        params: &FilesWatchParams,
+        req: &Channel,
+        dst: Option<&mut dyn std::io::Write>,
+    ) -> Result<DownloadResponse<Channel>> {
+        let rel_path = format!("files/{fileId}/watch", fileId = params.file_id);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+        let opt_request: Option<EmptyRequest> = None;
+        let opt_request = Some(req);
+
+        do_download(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "POST",
+            opt_request,
+            dst,
+        )
+        .await
     }
-  }
-
-
-/// Subscribes to changes to a file
-///
-/// This method downloads data.
-pub async fn watch(
-    &mut self, params: &FilesWatchParams, req: &Channel, dst: Option<&mut dyn std::io::Write>)
-    -> Result<DownloadResponse<Channel>> {
-
-    let rel_path = format!("files/{fileId}/watch", fileId=params.file_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
-    }
-
-    let full_uri = path + &url_params;
-    let opt_request: Option<EmptyRequest> = None;
-    let opt_request = Some(req);
-
-    do_download(&self.client, &full_uri, &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "POST", opt_request, dst).await
-  }
-
 }
 
 /// The Drive Permissions service represents the Permissions resource.
 pub struct PermissionsService {
     client: TlsClient,
-    authenticator: Box<dyn 'static + std::ops::Deref<Target=Authenticator>>,
+    authenticator: Box<dyn 'static + std::ops::Deref<Target = Authenticator>>,
     scopes: Vec<String>,
 }
 
@@ -4354,8 +5202,15 @@
     /// Create a new PermissionsService object. The easiest way to call this is wrapping the Authenticator
     /// into an `Rc`: `new(client.clone(), Rc::new(authenticator))`.
     /// This way, one authenticator can be shared among several services.
-    pub fn new<A: 'static + std::ops::Deref<Target=Authenticator>>(client: TlsClient, auth: A) -> PermissionsService {
-        PermissionsService { client: client, authenticator: Box::new(auth), scopes: vec![] }
+    pub fn new<A: 'static + std::ops::Deref<Target = Authenticator>>(
+        client: TlsClient,
+        auth: A,
+    ) -> PermissionsService {
+        PermissionsService {
+            client: client,
+            authenticator: Box::new(auth),
+            scopes: vec![],
+        }
     }
 
     /// Explicitly select which scopes should be requested for authorization. Otherwise,
@@ -4363,157 +5218,200 @@
     ///
     /// It is most convenient to supply a vec or slice of DriveScopes enum values.
     pub fn set_scopes<S: AsRef<str>, T: AsRef<[S]>>(&mut self, scopes: T) {
-        self.scopes = scopes.as_ref().into_iter().map(|s| s.as_ref().to_string()).collect();
-    }
-
-
-/// Creates a permission for a file or shared drive.
-pub async fn create(
-    &mut self, params: &PermissionsCreateParams, req: &Permission) -> Result<Permission> {
-
-    let rel_path = format!("files/{fileId}/permissions", fileId=params.file_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.file".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+        self.scopes = scopes
+            .as_ref()
+            .into_iter()
+            .map(|s| s.as_ref().to_string())
+            .collect();
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    let opt_request = Some(req);
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "POST", opt_request).await
-  }
-
-
-/// Deletes a permission.
-pub async fn delete(
-    &mut self, params: &PermissionsDeleteParams) -> Result<()> {
-
-    let rel_path = format!("files/{fileId}/permissions/{permissionId}", fileId=params.file_id,permissionId=params.permission_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.file".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
+    /// Creates a permission for a file or shared drive.
+    pub async fn create(
+        &mut self,
+        params: &PermissionsCreateParams,
+        req: &Permission,
+    ) -> Result<Permission> {
+        let rel_path = format!("files/{fileId}/permissions", fileId = params.file_id);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.file".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        let opt_request = Some(req);
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "POST",
+            opt_request,
+        )
+        .await
     }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+
+    /// Deletes a permission.
+    pub async fn delete(&mut self, params: &PermissionsDeleteParams) -> Result<()> {
+        let rel_path = format!(
+            "files/{fileId}/permissions/{permissionId}",
+            fileId = params.file_id,
+            permissionId = params.permission_id
+        );
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.file".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "DELETE",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "DELETE", opt_request).await
-  }
-
-
-/// Gets a permission by ID.
-pub async fn get(
-    &mut self, params: &PermissionsGetParams) -> Result<Permission> {
-
-    let rel_path = format!("files/{fileId}/permissions/{permissionId}", fileId=params.file_id,permissionId=params.permission_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Gets a permission by ID.
+    pub async fn get(&mut self, params: &PermissionsGetParams) -> Result<Permission> {
+        let rel_path = format!(
+            "files/{fileId}/permissions/{permissionId}",
+            fileId = params.file_id,
+            permissionId = params.permission_id
+        );
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "GET",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "GET", opt_request).await
-  }
-
-
-/// Lists a file's or shared drive's permissions.
-pub async fn list(
-    &mut self, params: &PermissionsListParams) -> Result<PermissionList> {
-
-    let rel_path = format!("files/{fileId}/permissions", fileId=params.file_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Lists a file's or shared drive's permissions.
+    pub async fn list(&mut self, params: &PermissionsListParams) -> Result<PermissionList> {
+        let rel_path = format!("files/{fileId}/permissions", fileId = params.file_id);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "GET",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "GET", opt_request).await
-  }
-
-
-/// Updates a permission with patch semantics.
-pub async fn update(
-    &mut self, params: &PermissionsUpdateParams, req: &Permission) -> Result<Permission> {
-
-    let rel_path = format!("files/{fileId}/permissions/{permissionId}", fileId=params.file_id,permissionId=params.permission_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.file".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
+    /// Updates a permission with patch semantics.
+    pub async fn update(
+        &mut self,
+        params: &PermissionsUpdateParams,
+        req: &Permission,
+    ) -> Result<Permission> {
+        let rel_path = format!(
+            "files/{fileId}/permissions/{permissionId}",
+            fileId = params.file_id,
+            permissionId = params.permission_id
+        );
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.file".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        let opt_request = Some(req);
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "PATCH",
+            opt_request,
+        )
+        .await
     }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
-    }
-
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    let opt_request = Some(req);
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "PATCH", opt_request).await
-  }
-
 }
 
 /// The Drive Replies service represents the Replies resource.
 pub struct RepliesService {
     client: TlsClient,
-    authenticator: Box<dyn 'static + std::ops::Deref<Target=Authenticator>>,
+    authenticator: Box<dyn 'static + std::ops::Deref<Target = Authenticator>>,
     scopes: Vec<String>,
 }
 
@@ -4521,8 +5419,15 @@
     /// Create a new RepliesService object. The easiest way to call this is wrapping the Authenticator
     /// into an `Rc`: `new(client.clone(), Rc::new(authenticator))`.
     /// This way, one authenticator can be shared among several services.
-    pub fn new<A: 'static + std::ops::Deref<Target=Authenticator>>(client: TlsClient, auth: A) -> RepliesService {
-        RepliesService { client: client, authenticator: Box::new(auth), scopes: vec![] }
+    pub fn new<A: 'static + std::ops::Deref<Target = Authenticator>>(
+        client: TlsClient,
+        auth: A,
+    ) -> RepliesService {
+        RepliesService {
+            client: client,
+            authenticator: Box::new(auth),
+            scopes: vec![],
+        }
     }
 
     /// Explicitly select which scopes should be requested for authorization. Otherwise,
@@ -4530,157 +5435,203 @@
     ///
     /// It is most convenient to supply a vec or slice of DriveScopes enum values.
     pub fn set_scopes<S: AsRef<str>, T: AsRef<[S]>>(&mut self, scopes: T) {
-        self.scopes = scopes.as_ref().into_iter().map(|s| s.as_ref().to_string()).collect();
-    }
-
-
-/// Creates a new reply to a comment.
-pub async fn create(
-    &mut self, params: &RepliesCreateParams, req: &Reply) -> Result<Reply> {
-
-    let rel_path = format!("files/{fileId}/comments/{commentId}/replies", fileId=params.file_id,commentId=params.comment_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.file".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+        self.scopes = scopes
+            .as_ref()
+            .into_iter()
+            .map(|s| s.as_ref().to_string())
+            .collect();
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    let opt_request = Some(req);
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "POST", opt_request).await
-  }
-
-
-/// Deletes a reply.
-pub async fn delete(
-    &mut self, params: &RepliesDeleteParams) -> Result<()> {
-
-    let rel_path = format!("files/{fileId}/comments/{commentId}/replies/{replyId}", fileId=params.file_id,commentId=params.comment_id,replyId=params.reply_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.file".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
+    /// Creates a new reply to a comment.
+    pub async fn create(&mut self, params: &RepliesCreateParams, req: &Reply) -> Result<Reply> {
+        let rel_path = format!(
+            "files/{fileId}/comments/{commentId}/replies",
+            fileId = params.file_id,
+            commentId = params.comment_id
+        );
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.file".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        let opt_request = Some(req);
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "POST",
+            opt_request,
+        )
+        .await
     }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+
+    /// Deletes a reply.
+    pub async fn delete(&mut self, params: &RepliesDeleteParams) -> Result<()> {
+        let rel_path = format!(
+            "files/{fileId}/comments/{commentId}/replies/{replyId}",
+            fileId = params.file_id,
+            commentId = params.comment_id,
+            replyId = params.reply_id
+        );
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.file".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "DELETE",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "DELETE", opt_request).await
-  }
-
-
-/// Gets a reply by ID.
-pub async fn get(
-    &mut self, params: &RepliesGetParams) -> Result<Reply> {
-
-    let rel_path = format!("files/{fileId}/comments/{commentId}/replies/{replyId}", fileId=params.file_id,commentId=params.comment_id,replyId=params.reply_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Gets a reply by ID.
+    pub async fn get(&mut self, params: &RepliesGetParams) -> Result<Reply> {
+        let rel_path = format!(
+            "files/{fileId}/comments/{commentId}/replies/{replyId}",
+            fileId = params.file_id,
+            commentId = params.comment_id,
+            replyId = params.reply_id
+        );
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "GET",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "GET", opt_request).await
-  }
-
-
-/// Lists a comment's replies.
-pub async fn list(
-    &mut self, params: &RepliesListParams) -> Result<ReplyList> {
-
-    let rel_path = format!("files/{fileId}/comments/{commentId}/replies", fileId=params.file_id,commentId=params.comment_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Lists a comment's replies.
+    pub async fn list(&mut self, params: &RepliesListParams) -> Result<ReplyList> {
+        let rel_path = format!(
+            "files/{fileId}/comments/{commentId}/replies",
+            fileId = params.file_id,
+            commentId = params.comment_id
+        );
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "GET",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "GET", opt_request).await
-  }
-
-
-/// Updates a reply with patch semantics.
-pub async fn update(
-    &mut self, params: &RepliesUpdateParams, req: &Reply) -> Result<Reply> {
-
-    let rel_path = format!("files/{fileId}/comments/{commentId}/replies/{replyId}", fileId=params.file_id,commentId=params.comment_id,replyId=params.reply_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.file".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
+    /// Updates a reply with patch semantics.
+    pub async fn update(&mut self, params: &RepliesUpdateParams, req: &Reply) -> Result<Reply> {
+        let rel_path = format!(
+            "files/{fileId}/comments/{commentId}/replies/{replyId}",
+            fileId = params.file_id,
+            commentId = params.comment_id,
+            replyId = params.reply_id
+        );
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.file".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        let opt_request = Some(req);
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "PATCH",
+            opt_request,
+        )
+        .await
     }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
-    }
-
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    let opt_request = Some(req);
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "PATCH", opt_request).await
-  }
-
 }
 
 /// The Drive Revisions service represents the Revisions resource.
 pub struct RevisionsService {
     client: TlsClient,
-    authenticator: Box<dyn 'static + std::ops::Deref<Target=Authenticator>>,
+    authenticator: Box<dyn 'static + std::ops::Deref<Target = Authenticator>>,
     scopes: Vec<String>,
 }
 
@@ -4688,8 +5639,15 @@
     /// Create a new RevisionsService object. The easiest way to call this is wrapping the Authenticator
     /// into an `Rc`: `new(client.clone(), Rc::new(authenticator))`.
     /// This way, one authenticator can be shared among several services.
-    pub fn new<A: 'static + std::ops::Deref<Target=Authenticator>>(client: TlsClient, auth: A) -> RevisionsService {
-        RevisionsService { client: client, authenticator: Box::new(auth), scopes: vec![] }
+    pub fn new<A: 'static + std::ops::Deref<Target = Authenticator>>(
+        client: TlsClient,
+        auth: A,
+    ) -> RevisionsService {
+        RevisionsService {
+            client: client,
+            authenticator: Box::new(auth),
+            scopes: vec![],
+        }
     }
 
     /// Explicitly select which scopes should be requested for authorization. Otherwise,
@@ -4697,131 +5655,174 @@
     ///
     /// It is most convenient to supply a vec or slice of DriveScopes enum values.
     pub fn set_scopes<S: AsRef<str>, T: AsRef<[S]>>(&mut self, scopes: T) {
-        self.scopes = scopes.as_ref().into_iter().map(|s| s.as_ref().to_string()).collect();
-    }
-
-
-/// Permanently deletes a file version. You can only delete revisions for files with binary content in Google Drive, like images or videos. Revisions for other files, like Google Docs or Sheets, and the last remaining file version can't be deleted.
-pub async fn delete(
-    &mut self, params: &RevisionsDeleteParams) -> Result<()> {
-
-    let rel_path = format!("files/{fileId}/revisions/{revisionId}", fileId=params.file_id,revisionId=params.revision_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.file".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+        self.scopes = scopes
+            .as_ref()
+            .into_iter()
+            .map(|s| s.as_ref().to_string())
+            .collect();
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "DELETE", opt_request).await
-  }
-
-
-/// Gets a revision's metadata or content by ID.
-///
-/// This method downloads data.
-pub async fn get(
-    &mut self, params: &RevisionsGetParams,  dst: Option<&mut dyn std::io::Write>)
-    -> Result<DownloadResponse<Revision>> {
-
-    let rel_path = format!("files/{fileId}/revisions/{revisionId}", fileId=params.file_id,revisionId=params.revision_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Permanently deletes a file version. You can only delete revisions for files with binary content in Google Drive, like images or videos. Revisions for other files, like Google Docs or Sheets, and the last remaining file version can't be deleted.
+    pub async fn delete(&mut self, params: &RevisionsDeleteParams) -> Result<()> {
+        let rel_path = format!(
+            "files/{fileId}/revisions/{revisionId}",
+            fileId = params.file_id,
+            revisionId = params.revision_id
+        );
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.file".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "DELETE",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-    let opt_request: Option<EmptyRequest> = None;
-
-    do_download(&self.client, &full_uri, &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "GET", opt_request, dst).await
-  }
-
-
-/// Lists a file's revisions.
-pub async fn list(
-    &mut self, params: &RevisionsListParams) -> Result<RevisionList> {
-
-    let rel_path = format!("files/{fileId}/revisions", fileId=params.file_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Gets a revision's metadata or content by ID.
+    ///
+    /// This method downloads data. Depending on the server returning a `Content-Type` of `application/json`
+    /// or a non-JSON type, the returned value indicates if a download took place or data was written to
+    /// `dst`. If `dst` is `None` despite data being available for download, `ApiError::DataAvailableError`
+    /// is returned.
+    pub async fn get(
+        &mut self,
+        params: &RevisionsGetParams,
+        dst: Option<&mut dyn std::io::Write>,
+    ) -> Result<DownloadResponse<Revision>> {
+        let rel_path = format!(
+            "files/{fileId}/revisions/{revisionId}",
+            fileId = params.file_id,
+            revisionId = params.revision_id
+        );
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+        let opt_request: Option<EmptyRequest> = None;
+
+        do_download(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "GET",
+            opt_request,
+            dst,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "GET", opt_request).await
-  }
-
-
-/// Updates a revision with patch semantics.
-pub async fn update(
-    &mut self, params: &RevisionsUpdateParams, req: &Revision) -> Result<Revision> {
-
-    let rel_path = format!("files/{fileId}/revisions/{revisionId}", fileId=params.file_id,revisionId=params.revision_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.file".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
+    /// Lists a file's revisions.
+    pub async fn list(&mut self, params: &RevisionsListParams) -> Result<RevisionList> {
+        let rel_path = format!("files/{fileId}/revisions", fileId = params.file_id);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "GET",
+            opt_request,
+        )
+        .await
     }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+
+    /// Updates a revision with patch semantics.
+    pub async fn update(
+        &mut self,
+        params: &RevisionsUpdateParams,
+        req: &Revision,
+    ) -> Result<Revision> {
+        let rel_path = format!(
+            "files/{fileId}/revisions/{revisionId}",
+            fileId = params.file_id,
+            revisionId = params.revision_id
+        );
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.file".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        let opt_request = Some(req);
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "PATCH",
+            opt_request,
+        )
+        .await
     }
-
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    let opt_request = Some(req);
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "PATCH", opt_request).await
-  }
-
 }
 
 /// The Drive Teamdrives service represents the Teamdrives resource.
 pub struct TeamdrivesService {
     client: TlsClient,
-    authenticator: Box<dyn 'static + std::ops::Deref<Target=Authenticator>>,
+    authenticator: Box<dyn 'static + std::ops::Deref<Target = Authenticator>>,
     scopes: Vec<String>,
 }
 
@@ -4829,8 +5830,15 @@
     /// Create a new TeamdrivesService object. The easiest way to call this is wrapping the Authenticator
     /// into an `Rc`: `new(client.clone(), Rc::new(authenticator))`.
     /// This way, one authenticator can be shared among several services.
-    pub fn new<A: 'static + std::ops::Deref<Target=Authenticator>>(client: TlsClient, auth: A) -> TeamdrivesService {
-        TeamdrivesService { client: client, authenticator: Box::new(auth), scopes: vec![] }
+    pub fn new<A: 'static + std::ops::Deref<Target = Authenticator>>(
+        client: TlsClient,
+        auth: A,
+    ) -> TeamdrivesService {
+        TeamdrivesService {
+            client: client,
+            authenticator: Box::new(auth),
+            scopes: vec![],
+        }
     }
 
     /// Explicitly select which scopes should be requested for authorization. Otherwise,
@@ -4838,149 +5846,189 @@
     ///
     /// It is most convenient to supply a vec or slice of DriveScopes enum values.
     pub fn set_scopes<S: AsRef<str>, T: AsRef<[S]>>(&mut self, scopes: T) {
-        self.scopes = scopes.as_ref().into_iter().map(|s| s.as_ref().to_string()).collect();
-    }
-
-
-/// Deprecated use drives.create instead.
-pub async fn create(
-    &mut self, params: &TeamdrivesCreateParams, req: &TeamDrive) -> Result<TeamDrive> {
-
-    let rel_path = format!("teamdrives", );
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+        self.scopes = scopes
+            .as_ref()
+            .into_iter()
+            .map(|s| s.as_ref().to_string())
+            .collect();
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    let opt_request = Some(req);
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "POST", opt_request).await
-  }
-
-
-/// Deprecated use drives.delete instead.
-pub async fn delete(
-    &mut self, params: &TeamdrivesDeleteParams) -> Result<()> {
-
-    let rel_path = format!("teamdrives/{teamDriveId}", teamDriveId=params.team_drive_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
+    /// Deprecated use drives.create instead.
+    pub async fn create(
+        &mut self,
+        params: &TeamdrivesCreateParams,
+        req: &TeamDrive,
+    ) -> Result<TeamDrive> {
+        let rel_path = format!("teamdrives",);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        let opt_request = Some(req);
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "POST",
+            opt_request,
+        )
+        .await
     }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+
+    /// Deprecated use drives.delete instead.
+    pub async fn delete(&mut self, params: &TeamdrivesDeleteParams) -> Result<()> {
+        let rel_path = format!(
+            "teamdrives/{teamDriveId}",
+            teamDriveId = params.team_drive_id
+        );
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "DELETE",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "DELETE", opt_request).await
-  }
-
-
-/// Deprecated use drives.get instead.
-pub async fn get(
-    &mut self, params: &TeamdrivesGetParams) -> Result<TeamDrive> {
-
-    let rel_path = format!("teamdrives/{teamDriveId}", teamDriveId=params.team_drive_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Deprecated use drives.get instead.
+    pub async fn get(&mut self, params: &TeamdrivesGetParams) -> Result<TeamDrive> {
+        let rel_path = format!(
+            "teamdrives/{teamDriveId}",
+            teamDriveId = params.team_drive_id
+        );
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "GET",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "GET", opt_request).await
-  }
-
-
-/// Deprecated use drives.list instead.
-pub async fn list(
-    &mut self, params: &TeamdrivesListParams) -> Result<TeamDriveList> {
-
-    let rel_path = format!("teamdrives", );
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
-    }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
+    /// Deprecated use drives.list instead.
+    pub async fn list(&mut self, params: &TeamdrivesListParams) -> Result<TeamDriveList> {
+        let rel_path = format!("teamdrives",);
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive.readonly".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "GET",
+            opt_request,
+        )
+        .await
     }
 
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "GET", opt_request).await
-  }
-
-
-/// Deprecated use drives.update instead
-pub async fn update(
-    &mut self, params: &TeamdrivesUpdateParams, req: &TeamDrive) -> Result<TeamDrive> {
-
-    let rel_path = format!("teamdrives/{teamDriveId}", teamDriveId=params.team_drive_id);
-    let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
-    let tok;
-    if self.scopes.is_empty() {
-        let scopes = &["https://www.googleapis.com/auth/drive".to_string(),
-        ];
-        tok = self.authenticator.token(scopes).await?;
-    } else {
-        tok = self.authenticator.token(&self.scopes).await?;
+    /// Deprecated use drives.update instead
+    pub async fn update(
+        &mut self,
+        params: &TeamdrivesUpdateParams,
+        req: &TeamDrive,
+    ) -> Result<TeamDrive> {
+        let rel_path = format!(
+            "teamdrives/{teamDriveId}",
+            teamDriveId = params.team_drive_id
+        );
+        let path = "https://www.googleapis.com/drive/v3/".to_string() + &rel_path;
+        let tok;
+        if self.scopes.is_empty() {
+            let scopes = &["https://www.googleapis.com/auth/drive".to_string()];
+            tok = self.authenticator.token(scopes).await?;
+        } else {
+            tok = self.authenticator.token(&self.scopes).await?;
+        }
+        let mut url_params = format!("?{params}", params = params);
+        if let Some(ref api_params) = &params.drive_params {
+            url_params.push_str(&format!("{}", api_params));
+        }
+
+        let full_uri = path + &url_params;
+
+        let opt_request: Option<EmptyRequest> = None;
+        let opt_request = Some(req);
+        do_request(
+            &self.client,
+            &full_uri,
+            &[(
+                hyper::header::AUTHORIZATION,
+                format!("Bearer {token}", token = tok.as_str()),
+            )],
+            "PATCH",
+            opt_request,
+        )
+        .await
     }
-    let mut url_params = format!("?{params}", params=params);
-    if let Some(ref api_params) = &params.drive_params {
-        url_params.push_str(&format!("{}", api_params));
-    }
-
-    let full_uri = path + &url_params;
-
-    let opt_request: Option<EmptyRequest> = None;
-    let opt_request = Some(req);
-    do_request(&self.client, &full_uri,
-        &[(hyper::header::AUTHORIZATION, format!("Bearer {token}", token=tok.as_str()))],
-        "PATCH", opt_request).await
-  }
-
 }
--- a/gcs_example/src/storage_v1_types.rs	Sun Oct 25 14:53:07 2020 +0100
+++ b/gcs_example/src/storage_v1_types.rs	Sun Oct 25 15:07:36 2020 +0100
@@ -3,6 +3,12 @@
 //!
 //! (c) 2020 Lewin Bormann <lbo@spheniscida.de>
 //!
+//! ## Getting started
+//!
+//! **Tip**: Take a look at those types ending in `...Service`. These represent API resources
+//! and contain methods to interact with an API. The remaining types are used by those methods
+//! and can be explored starting from a method you want to use.
+//!
 //! I'd be happy if you let me know about your use case of this code.
 //!
 //! THIS FILE HAS BEEN GENERATED -- SAVE ANY MODIFICATIONS BEFORE REPLACING.
--- a/generate/templates.py	Sun Oct 25 14:53:07 2020 +0100
+++ b/generate/templates.py	Sun Oct 25 15:07:36 2020 +0100
@@ -5,6 +5,12 @@
 //!
 //! (c) 2020 Lewin Bormann <lbo@spheniscida.de>
 //!
+//! ## Getting started
+//! 
+//! **Tip**: Take a look at those types ending in `...Service`. These represent API resources
+//! and contain methods to interact with an API. The remaining types are used by those methods
+//! and can be explored starting from a method you want to use.
+//!
 //! I'd be happy if you let me know about your use case of this code.
 //!
 //! THIS FILE HAS BEEN GENERATED -- SAVE ANY MODIFICATIONS BEFORE REPLACING.